Unity中获取离线时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using UnityEngine;

public class Test : MonoBehaviour
{
    private void Awake()
    {
        //将TimeSpan结构的新实例初始化为指定的刻度数
        TimeSpan t1 = new TimeSpan(36); //00:00:00.0000036

        //将TimeSpan结构的新实例初始化为指定的小时数、分钟数和秒数
        TimeSpan t2 = new TimeSpan(20, 35, 21); //20:35:21

        //将TimeSpan结构的新实例初始化为指定的天数、小时数、分钟数和秒数
        TimeSpan t3 = new TimeSpan(4, 20, 35, 21); //4:20:35:21
        TimeSpan t4 = new TimeSpan(4, 24, 35, 21); //*****自动进位5:00:35:21

        //将TimeSpan结构的新实例初始化为指定的天数、小时数、分钟数、秒数和毫秒数(1秒=1000毫秒)
        TimeSpan t5 = new TimeSpan(4, 20, 35, 21, 60); //4:20:35:21:0600000

        //直接取出TimeSpan结构所表示的时间间隔的天数、小时数、分钟数、秒数和毫秒数
        TimeSpan t6 = new TimeSpan(4, 20, 35, 21, 60);
        Debug.Log(String.Format("天数：{0}n小时数：{1}n分钟数：{2}n秒数：{3}n毫秒数：{4}", t6.Days, t6.Hours, t6.Minutes, t6.Seconds,
            t6.Milliseconds)); //天数：4    小时数：20    分钟数：35    秒数：21    毫秒数：60

        //将TimeSpan结构所表示的时间间隔换算成等效天数、小时数、分钟数、秒数和毫秒数
        TimeSpan t7 = new TimeSpan(4, 20, 35, 21, 60);
        Debug.Log(String.Format("等效天数：{0}n等效小时数：{1}n等效分钟数：{2}n等效秒数：{3}n等效毫秒数：{4}", t7.TotalDays, t7.TotalHours, t7.TotalMinutes, t7.TotalSeconds,
            t7.TotalMilliseconds)); //等效天数：4.857...    等效小时数：116.58...    等效分钟数：6995.3...    等效秒数：419721...    等效毫秒数：419721060
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using UnityEngine;

public class OfflineMgr : MonoBehaviour
{
    private void OnApplicationPause(bool pause)
    {
        if (pause)
        {
            PlayerPrefs.SetString("lastOffline", UnbiasedTime.Ins.Now().ToBinary().ToString());
        }
        else
        {
            //TODO：获得离线收益
        }
    }

    private void OnApplicationQuit()
    {

    }

    public double GetOfflineTime()
    {
        string lastOfflineTime = PlayerPrefs.GetString("lastOffline", "0");
        DateTime last = DateTime.FromBinary(long.Parse(lastOfflineTime));
        DateTime now = UnbiasedTime.Ins.Now();
        double restTime = (now - last).TotalSeconds;
        return restTime;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
using UnityEngine;
using System;
using System.Collections;
using System.Runtime.InteropServices;
using System.Threading;

/// <summary>
/// 防作弊时间
/// </summary>
public class UnbiasedTime : MonoBehaviour
{
    const bool UseTimeZone_CN = true;//是否为中国时区+8

    const int TimeZone_CN = 8;//中国时区

    private static UnbiasedTime _instance;
    public static UnbiasedTime Ins
    {
        get
        {
            if (_instance != null) return _instance;

            var go = new GameObject("UnbiasedTime");
            _instance = go.AddComponent<UnbiasedTime>();
            DontDestroyOnLoad(go);
            return _instance;
        }
    }

    // Estimated difference in seconds between device time and real world time
    // timeOffset = deviceTime - worldTime;
    [HideInInspector] public long timeOffset = 0;

    void Awake()
    {
        SessionStart();
    }

    void OnApplicationPause(bool pause)
    {
        if (pause)
        {
            SessionEnd();
        }
        else
        {
            SessionStart();
        }
    }

    void OnApplicationQuit()
    {
        SessionEnd();
    }

    /// <summary>
    /// 获取当前时间
    /// </summary>
    public DateTime Now()
    {
        if (UseTimeZone_CN)
        {
            return getNow().ToUniversalTime().AddHours(TimeZone_CN);
        }
        else
        {
            return getNow();
        }
    }
    private DateTime getNow()
    {
        return DateTime.Now.AddSeconds(-1.0f * timeOffset);
    }

    // timeOffset value is cached for performance reasons (calls to native plugins can be expensive). 
    // This method is used to update offset value in cases if you think device time was changed by user. 
    // 
    // However, time offset is updated automatically when app gets backgrounded or foregrounded. 
    // 
    public void UpdateTimeOffset()
    {
#if UNITY_ANDROID
		UpdateTimeOffsetAndroid();
#elif UNITY_IPHONE
        UpdateTimeOffsetIOS();
#endif
    }

    // Returns true if native plugin was unable to calculate unbiased time and had fallen back to device DateTime. 
    // This can happen after device reboot. Player can cheat by closing the game, changing time and rebooting device. 
    // This method can help tracking this situation. 
    public bool IsUsingSystemTime()
    {
#if UNITY_ANDROID
		return UsingSystemTimeAndroid();
#elif UNITY_IPHONE
        return UsingSystemTimeIOS();
#else
        return true;
#endif
    }

    private void SessionStart()
    {
#if UNITY_ANDROID
		StartAndroid();
#elif UNITY_IPHONE
        StartIOS();
#endif
    }

    private void SessionEnd()
    {
#if UNITY_ANDROID
		EndAndroid();
#elif UNITY_IPHONE
        EndIOS();
#endif
    }

    /// <summary>
    /// Platform specific code
    /// </summary>
#if UNITY_IPHONE
    [DllImport("__Internal")]
    private static extern void _vtcOnSessionStart();

    [DllImport("__Internal")]
    private static extern void _vtcOnSessionEnd();

    [DllImport("__Internal")]
    private static extern int _vtcTimestampOffset();

    [DllImport("__Internal")]
    private static extern int _vtcUsingSystemTime();

    private void UpdateTimeOffsetIOS()
    {
        if (Application.platform != RuntimePlatform.IPhonePlayer)
        {
            return;
        }

        timeOffset = _vtcTimestampOffset();
    }

    private void StartIOS()
    {
        if (Application.platform != RuntimePlatform.IPhonePlayer)
        {
            return;
        }

        _vtcOnSessionStart();
        timeOffset = _vtcTimestampOffset();
    }

    private void EndIOS()
    {
        if (Application.platform != RuntimePlatform.IPhonePlayer)
        {
            return;
        }

        _vtcOnSessionEnd();
    }

    private bool UsingSystemTimeIOS()
    {
        if (Application.platform != RuntimePlatform.IPhonePlayer)
        {
            return true;
        }

        return _vtcUsingSystemTime() != 0;
    }
#endif


#if UNITY_ANDROID
	private void UpdateTimeOffsetAndroid() {
		if (Application.platform != RuntimePlatform.Android) {
			return;
		}

		using (var activityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer")) 
		using (var unbiasedTimeClass = new AndroidJavaClass("com.vasilij.unbiasedtime.UnbiasedTime")) {
			var playerActivityContext = activityClass.GetStatic<AndroidJavaObject>("currentActivity");
			if (playerActivityContext != null && unbiasedTimeClass != null) {
				timeOffset = unbiasedTimeClass.CallStatic <long> ("vtcTimestampOffset", playerActivityContext);
			}
		}		
	}

	private void StartAndroid() {
		if (Application.platform != RuntimePlatform.Android) {
			return;
		}

		using (var activityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
		using (var unbiasedTimeClass = new AndroidJavaClass("com.vasilij.unbiasedtime.UnbiasedTime")) {
			var playerActivityContext = activityClass.GetStatic<AndroidJavaObject>("currentActivity");
			if (playerActivityContext != null && unbiasedTimeClass != null) {
				unbiasedTimeClass.CallStatic ("vtcOnSessionStart", playerActivityContext);
				timeOffset = unbiasedTimeClass.CallStatic <long> ("vtcTimestampOffset");
			}
		}
	}

	private void EndAndroid() {
		if (Application.platform != RuntimePlatform.Android) {
			return;
		}

		using (var activityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer")) 
		using (var unbiasedTimeClass = new AndroidJavaClass("com.vasilij.unbiasedtime.UnbiasedTime")) {
			var playerActivityContext = activityClass.GetStatic<AndroidJavaObject>("currentActivity");
			if (playerActivityContext != null && unbiasedTimeClass != null) {
				unbiasedTimeClass.CallStatic ("vtcOnSessionEnd", playerActivityContext);
			}
		}
	}

	private bool UsingSystemTimeAndroid() {
		if (Application.platform != RuntimePlatform.Android) {
			return true;
		}
		
		using (var activityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer")) 
		using (var unbiasedTimeClass = new AndroidJavaClass("com.vasilij.unbiasedtime.UnbiasedTime")) {
			var playerActivityContext = activityClass.GetStatic<AndroidJavaObject>("currentActivity");
			if (playerActivityContext != null && unbiasedTimeClass != null) {
				return unbiasedTimeClass.CallStatic <bool> ("vtcUsingDeviceTime");
			}
		}
		return true;
	}
#endif
}