Implement time:* 4.0.0 commands (#736)

* Abstract SteadyClockCore to follow Nintendo changes in 4.x

This is the ground work for 4.0.0 support

* Implement TickBasedSteadyClockCore

Preparation for the ephemeral clock.

* Refactor SystemClockCore to follow 4.0.0 changes

* Implement EphemeralNetworkSystemClock

* Implement GetSnapshotClock & GetSnapshotClockFromSystemClockContext

* Implement CalculateStandardUserSystemClockDifferenceByUser & CalculateSpanBetween

* Remove an outdated comment & unused import

* Fix a nit and GetClockSnapshot

* Address comment

1 files changed, 22 insertions, 91 deletions

diff --git a/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs b/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs
index e661ab53..54d9accf 100644
--- a/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs
+++ b/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs
@@ -1,54 +1,16 @@
 using Ryujinx.HLE.HOS.Kernel.Threading;
-using Ryujinx.HLE.HOS.Services.Bpc;
 using Ryujinx.HLE.Utilities;
 using System;
 
 namespace Ryujinx.HLE.HOS.Services.Time.Clock
 {
-    class SteadyClockCore
+    abstract class SteadyClockCore
     {
-        private long         _setupValue;
-        private ResultCode   _setupResultCode;
-        private bool         _isRtcResetDetected;
-        private TimeSpanType _testOffset;
-        private TimeSpanType _internalOffset;
-        private UInt128      _clockSourceId;
+        private UInt128 _clockSourceId;
 
-        private static SteadyClockCore instance;
-
-        public static SteadyClockCore Instance
-        {
-            get
-            {
-                if (instance == null)
-                {
-                    instance = new SteadyClockCore();
-                }
-
-                return instance;
-            }
-        }
-
-        private SteadyClockCore()
-        {
-            _testOffset     = new TimeSpanType(0);
-            _internalOffset = new TimeSpanType(0);
-            _clockSourceId  = new UInt128(Guid.NewGuid().ToByteArray());
-        }
-
-        private SteadyClockTimePoint GetTimePoint(KThread thread)
+        public SteadyClockCore()
         {
-            SteadyClockTimePoint result = new SteadyClockTimePoint
-            {
-                TimePoint     = 0,
-                ClockSourceId = _clockSourceId
-            };
-
-            TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.ThreadState.CntpctEl0, thread.Context.ThreadState.CntfrqEl0);
-
-            result.TimePoint = _setupValue + ticksTimeSpan.ToSeconds();
-
-            return result;
+            _clockSourceId = new UInt128(Guid.NewGuid().ToByteArray());
         }
 
         public UInt128 GetClockSourceId()
@@ -56,76 +18,45 @@ namespace Ryujinx.HLE.HOS.Services.Time.Clock
             return _clockSourceId;
         }
 
-        public SteadyClockTimePoint GetCurrentTimePoint(KThread thread)
-        {
-            SteadyClockTimePoint result = GetTimePoint(thread);
-
-            result.TimePoint += _testOffset.ToSeconds();
-            result.TimePoint += _internalOffset.ToSeconds();
-
-            return result;
-        }
-
-        public TimeSpanType GetTestOffset()
+        public virtual TimeSpanType GetTestOffset()
         {
-            return _testOffset;
+            return new TimeSpanType(0);
         }
 
-        public void SetTestOffset(TimeSpanType testOffset)
-        {
-            _testOffset = testOffset;
-        }
+        public virtual void SetTestOffset(TimeSpanType testOffset) {}
 
-        public ResultCode GetRtcValue(out ulong rtcValue)
+        public virtual ResultCode GetRtcValue(out ulong rtcValue)
         {
-            return (ResultCode)IRtcManager.GetExternalRtcValue(out rtcValue);
-        }
+            rtcValue = 0;
 
-        public bool IsRtcResetDetected()
-        {
-            return _isRtcResetDetected;
+            return ResultCode.NotImplemented;
         }
 
-        public ResultCode GetSetupResultCode()
+        public virtual ResultCode GetSetupResultValue()
         {
-            return _setupResultCode;
+            return ResultCode.NotImplemented;
         }
 
-        public TimeSpanType GetInternalOffset()
+        public virtual TimeSpanType GetInternalOffset()
         {
-            return _internalOffset;
+            return new TimeSpanType(0);
         }
 
-        public void SetInternalOffset(TimeSpanType internalOffset)
-        {
-            _internalOffset = internalOffset;
-        }
+        public virtual void SetInternalOffset(TimeSpanType internalOffset) {}
 
-        public ResultCode GetSetupResultValue()
+        public virtual SteadyClockTimePoint GetTimePoint(KThread thread)
         {
-            return _setupResultCode;
+            throw new NotImplementedException();
         }
 
-        public void ConfigureSetupValue()
+        public SteadyClockTimePoint GetCurrentTimePoint(KThread thread)
         {
-            int retry = 0;
-
-            ResultCode result = ResultCode.Success;
-
-            while (retry < 20)
-            {
-                result = (ResultCode)IRtcManager.GetExternalRtcValue(out ulong rtcValue);
-
-                if (result == ResultCode.Success)
-                {
-                    _setupValue = (long)rtcValue;
-                    break;
-                }
+            SteadyClockTimePoint result = GetTimePoint(thread);
 
-                retry++;
-            }
+            result.TimePoint += GetTestOffset().ToSeconds();
+            result.TimePoint += GetInternalOffset().ToSeconds();
 
-            _setupResultCode = result;
+            return result;
         }
     }
 }