2019-07-04 11:20:40 -04:00
|
|
|
using ChocolArm64.Memory;
|
|
|
|
using Ryujinx.Common;
|
2018-10-17 13:15:50 -04:00
|
|
|
using Ryujinx.Common.Logging;
|
2019-07-04 11:20:40 -04:00
|
|
|
using Ryujinx.HLE.HOS.Services.Time.TimeZone;
|
2018-02-25 13:58:16 -05:00
|
|
|
using System;
|
2018-07-13 17:35:19 -04:00
|
|
|
using System.Text;
|
2018-02-25 13:58:16 -05:00
|
|
|
|
2018-08-16 19:47:36 -04:00
|
|
|
using static Ryujinx.HLE.HOS.ErrorCode;
|
|
|
|
|
|
|
|
namespace Ryujinx.HLE.HOS.Services.Time
|
2018-02-25 13:58:16 -05:00
|
|
|
{
|
2018-03-19 14:58:46 -04:00
|
|
|
class ITimeZoneService : IpcService
|
2018-02-25 13:58:16 -05:00
|
|
|
{
|
2019-07-11 21:13:43 -04:00
|
|
|
public ITimeZoneService() { }
|
2018-02-25 13:58:16 -05:00
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(0)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// GetDeviceLocationName() -> nn::time::LocationName
|
2018-12-06 06:16:24 -05:00
|
|
|
public long GetDeviceLocationName(ServiceCtx context)
|
2018-04-22 00:21:49 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
char[] tzName = TimeZoneManager.Instance.GetDeviceLocationName().ToCharArray();
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
int padding = 0x24 - tzName.Length;
|
2018-04-22 00:21:49 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (padding < 0)
|
|
|
|
{
|
|
|
|
return MakeError(ErrorModule.Time, TimeError.LocationNameTooLong);
|
|
|
|
}
|
|
|
|
|
|
|
|
context.ResponseData.Write(tzName);
|
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
for (int index = 0; index < padding; index++)
|
2018-04-22 00:21:49 -04:00
|
|
|
{
|
2018-12-06 06:16:24 -05:00
|
|
|
context.ResponseData.Write((byte)0);
|
2018-04-22 00:21:49 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(1)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// SetDeviceLocationName(nn::time::LocationName)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long SetDeviceLocationName(ServiceCtx context)
|
2018-02-25 13:58:16 -05:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
string locationName = Encoding.ASCII.GetString(context.RequestData.ReadBytes(0x24)).TrimEnd('\0');
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
return TimeZoneManager.Instance.SetDeviceLocationName(locationName);
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(2)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// GetTotalLocationNameCount() -> u32
|
2018-12-06 06:16:24 -05:00
|
|
|
public long GetTotalLocationNameCount(ServiceCtx context)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
context.ResponseData.Write(TimeZoneManager.Instance.GetTotalLocationNameCount());
|
2018-07-13 17:35:19 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(3)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// LoadLocationNameList(u32 index) -> (u32 outCount, buffer<nn::time::LocationName, 6>)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long LoadLocationNameList(ServiceCtx context)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
// TODO: fix logic to use index
|
|
|
|
uint index = context.RequestData.ReadUInt32();
|
|
|
|
long bufferPosition = context.Request.ReceiveBuff[0].Position;
|
|
|
|
long bufferSize = context.Request.ReceiveBuff[0].Size;
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
uint errorCode = TimeZoneManager.Instance.LoadLocationNameList(index, out string[] locationNameArray, (uint)bufferSize / 0x24);
|
2018-08-16 19:47:36 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (errorCode == 0)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
uint offset = 0;
|
|
|
|
|
|
|
|
foreach (string locationName in locationNameArray)
|
|
|
|
{
|
|
|
|
int padding = 0x24 - locationName.Length;
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (padding < 0)
|
|
|
|
{
|
|
|
|
return MakeError(ErrorModule.Time, TimeError.LocationNameTooLong);
|
|
|
|
}
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
context.Memory.WriteBytes(bufferPosition + offset, Encoding.ASCII.GetBytes(locationName));
|
|
|
|
MemoryHelper.FillWithZeros(context.Memory, bufferPosition + offset + locationName.Length, padding);
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
offset += 0x24;
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
context.ResponseData.Write((uint)locationNameArray.Length);
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
2018-08-16 19:47:36 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
return errorCode;
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(4)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// LoadTimeZoneRule(nn::time::LocationName locationName) -> buffer<nn::time::TimeZoneRule, 0x16>
|
2018-12-06 06:16:24 -05:00
|
|
|
public long LoadTimeZoneRule(ServiceCtx context)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2018-12-06 06:16:24 -05:00
|
|
|
long bufferPosition = context.Request.ReceiveBuff[0].Position;
|
|
|
|
long bufferSize = context.Request.ReceiveBuff[0].Size;
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
if (bufferSize != 0x4000)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
// TODO: find error code here
|
|
|
|
Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
|
2018-02-25 13:58:16 -05:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
throw new InvalidOperationException();
|
|
|
|
}
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2018-08-16 19:47:36 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
string locationName = Encoding.ASCII.GetString(context.RequestData.ReadBytes(0x24)).TrimEnd('\0');
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
long resultCode = TimeZoneManager.Instance.LoadTimeZoneRules(out TimeZoneRule rules, locationName);
|
|
|
|
|
|
|
|
// Write TimeZoneRule if success
|
|
|
|
if (resultCode == 0)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
MemoryHelper.Write(context.Memory, bufferPosition, rules);
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
return resultCode;
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(100)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long ToCalendarTime(ServiceCtx context)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2018-12-06 06:16:24 -05:00
|
|
|
long posixTime = context.RequestData.ReadInt64();
|
|
|
|
long bufferPosition = context.Request.SendBuff[0].Position;
|
|
|
|
long bufferSize = context.Request.SendBuff[0].Size;
|
2018-04-10 20:16:27 -04:00
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
if (bufferSize != 0x4000)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
// TODO: find error code here
|
|
|
|
Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
|
2018-02-25 13:58:16 -05:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
throw new InvalidOperationException();
|
|
|
|
}
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
TimeZoneRule rules = MemoryHelper.Read<TimeZoneRule>(context.Memory, bufferPosition);
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
long resultCode = TimeZoneManager.ToCalendarTime(rules, posixTime, out CalendarInfo calendar);
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (resultCode == 0)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
context.ResponseData.WriteStruct(calendar);
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
return resultCode;
|
2018-07-13 17:35:19 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(101)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// ToCalendarTimeWithMyRule(nn::time::PosixTime) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long ToCalendarTimeWithMyRule(ServiceCtx context)
|
2018-07-13 17:35:19 -04:00
|
|
|
{
|
2018-12-06 06:16:24 -05:00
|
|
|
long posixTime = context.RequestData.ReadInt64();
|
2018-07-13 17:35:19 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
long resultCode = TimeZoneManager.Instance.ToCalendarTimeWithMyRules(posixTime, out CalendarInfo calendar);
|
|
|
|
|
|
|
|
if (resultCode == 0)
|
|
|
|
{
|
|
|
|
context.ResponseData.WriteStruct(calendar);
|
|
|
|
}
|
|
|
|
|
|
|
|
return resultCode;
|
2018-02-25 13:58:16 -05:00
|
|
|
}
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(201)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// ToPosixTime(nn::time::CalendarTime calendarTime, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long ToPosixTime(ServiceCtx context)
|
2018-08-15 14:53:23 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
long inBufferPosition = context.Request.SendBuff[0].Position;
|
|
|
|
long inBufferSize = context.Request.SendBuff[0].Size;
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (inBufferSize != 0x4000)
|
2018-08-15 14:53:23 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
// TODO: find error code here
|
|
|
|
Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{inBufferSize:x} (expected 0x4000)");
|
2018-08-16 19:47:36 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
throw new InvalidOperationException();
|
|
|
|
}
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
TimeZoneRule rules = MemoryHelper.Read<TimeZoneRule>(context.Memory, inBufferPosition);
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
long resultCode = TimeZoneManager.ToPosixTime(rules, calendarTime, out long posixTime);
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (resultCode == 0)
|
2018-08-15 14:53:23 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
long outBufferPosition = context.Request.RecvListBuff[0].Position;
|
|
|
|
long outBufferSize = context.Request.RecvListBuff[0].Size;
|
2018-08-16 19:47:36 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
context.Memory.WriteInt64(outBufferPosition, posixTime);
|
|
|
|
context.ResponseData.Write(1);
|
2018-08-15 14:53:23 -04:00
|
|
|
}
|
|
|
|
|
2018-12-06 06:16:24 -05:00
|
|
|
return resultCode;
|
2018-08-15 14:53:23 -04:00
|
|
|
}
|
|
|
|
|
2019-07-11 21:13:43 -04:00
|
|
|
[Command(202)]
|
2019-07-04 11:20:40 -04:00
|
|
|
// ToPosixTimeWithMyRule(nn::time::CalendarTime calendarTime) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
|
2018-12-06 06:16:24 -05:00
|
|
|
public long ToPosixTimeWithMyRule(ServiceCtx context)
|
2018-08-15 14:53:23 -04:00
|
|
|
{
|
2019-07-04 11:20:40 -04:00
|
|
|
CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
long resultCode = TimeZoneManager.Instance.ToPosixTimeWithMyRules(calendarTime, out long posixTime);
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
if (resultCode == 0)
|
|
|
|
{
|
|
|
|
long outBufferPosition = context.Request.RecvListBuff[0].Position;
|
|
|
|
long outBufferSize = context.Request.RecvListBuff[0].Size;
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
context.Memory.WriteInt64(outBufferPosition, posixTime);
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
// There could be only one result on one calendar as leap seconds aren't supported.
|
|
|
|
context.ResponseData.Write(1);
|
|
|
|
}
|
2018-08-15 14:53:23 -04:00
|
|
|
|
2019-07-04 11:20:40 -04:00
|
|
|
return resultCode;
|
2018-08-15 14:53:23 -04:00
|
|
|
}
|
2018-02-25 13:58:16 -05:00
|
|
|
}
|
2019-07-11 21:13:43 -04:00
|
|
|
}
|