private async void getCentralTime()
{
//Get the Real Time, only try three times
for (int i = 0; i < 3; ++i)
{
try
{
while (true)
{
var client = new Yort.Ntp.NtpClient();
var currentTime = await client.RequestTimeAsync();
if (currentTime != null)
{
Debug.WriteLine(currentTime);
deviceStartTime = DateTime.UtcNow;
realStartTime = (DateTime)currentTime;
break;
}
}
Debug.WriteLine("Try to get NTP time succeed");
break;
}
catch
{
Debug.WriteLine("Try to get NTP time failed.");
}
}
}
public void NtpClient_DefaultServer_GetsValidResponsesOverMultipleRequests()
{
var ntpEpoch = new DateTime(1900, 01, 01, 0, 0, 0, DateTimeKind.Utc);
_GotResultSignal = new System.Threading.AutoResetEvent(false);
var client = new Yort.Ntp.NtpClient();
try
{
client.TimeReceived += Client_TimeReceived;
client.ErrorOccurred += Client_ErrorOccurred;
for (int cnt = 0; cnt < 60; cnt++)
{
client.BeginRequestTime();
_GotResultSignal.WaitOne(2000);
Assert.IsNotNull(_Result);
Assert.AreNotEqual(ntpEpoch, _Result);
}
}
finally
{
client.TimeReceived -= this.Client_TimeReceived;
client.ErrorOccurred -= this.Client_ErrorOccurred;
}
}
public async Task WinRT_NtpClient_DefaultServer_GetAsyncReturnsResponse()
{
var client = new Yort.Ntp.NtpClient();
var result = await client.RequestTimeAsync();
Assert.AreNotEqual(DateTime.Now, result.NtpTime);
Assert.AreEqual(DateTimeKind.Utc, result.ReceivedAt.Kind);
}
public static void GetDate()
{
try
{
while (true)
{
var client = new Yort.Ntp.NtpClient("0.europe.pool.ntp.org");
CurrentTime = client.RequestTimeAsync().Result;
Console.WriteLine(CurrentTime);
Thread.Sleep(1000);
}
}
catch (Exception)
{
GetDate();
}
}
public void NtpClient_DefaultServer_GetsNonNullResponse()
{
_GotResultSignal = new System.Threading.AutoResetEvent(false);
var client = new Yort.Ntp.NtpClient();
try
{
client.TimeReceived += Client_TimeReceived;
client.ErrorOccurred += Client_ErrorOccurred;
client.BeginRequestTime();
_GotResultSignal.WaitOne(1000);
Assert.AreNotEqual(null, _Result);
}
finally
{
client.TimeReceived -= this.Client_TimeReceived;
client.ErrorOccurred -= this.Client_ErrorOccurred;
}
}
public void NtpClient_DefaultServer_GetsNonNullResponse()
{
_GotResultSignal = new System.Threading.AutoResetEvent(false);
var client = new Yort.Ntp.NtpClient();
try
{
client.TimeReceived += Client_TimeReceived;
client.ErrorOccurred += Client_ErrorOccurred;
client.BeginRequestTime();
_GotResultSignal.WaitOne(1000);
Assert.IsNotNull(_Result);
}
finally
{
client.TimeReceived -= this.Client_TimeReceived;
client.ErrorOccurred -= this.Client_ErrorOccurred;
}
}
public async Task WinRT_NtpClient_DefaultServer_ClientCanBeReused()
{
int successCount = 0;
var client = new Yort.Ntp.NtpClient();
for (int cnt = 0; cnt < 100; cnt++)
{
try
{
var currentTime = await client.RequestTimeAsync();
successCount++;
Assert.AreNotEqual(DateTime.Now, currentTime);
await Task.Delay(500);
}
catch (NtpNetworkException)
{
}
}
Assert.AreNotEqual(0, successCount);
}
public async Task WinRT_NtpClient_DefaultServer_GetsNonNullResponse()
{
var ntpClient = new Yort.Ntp.NtpClient();
try
{
_GotTimeTaskCompletionSource = new TaskCompletionSource<DateTime?>();
ntpClient.TimeReceived += ntpClient_TimeReceived;
ntpClient.ErrorOccurred += NtpClient_ErrorOccurred;
ntpClient.BeginRequestTime();
var result = await _GotTimeTaskCompletionSource.Task;
Assert.AreNotEqual(null, result);
}
finally
{
ntpClient.TimeReceived -= ntpClient_TimeReceived;
}
}
public async Task InitializeNtp()
{
try
{
string randomServer = NtpServers[new Random().Next(NtpServers.Count)];
Debug.WriteLine($"Starting NTP client: {randomServer}");
var client = new Yort.Ntp.NtpClient(randomServer);
CurrentNtpTime = await client.RequestTimeAsync();
Debug.WriteLine($"Received time: {CurrentNtpTime}");
CurrentNtpTimeBase = DateTimeOffset.UtcNow;
DifferenceBetweenNtpAndSystem = CurrentNtpTimeBase - CurrentNtpTime;
Debug.WriteLine($"System-NTP Diff: {DifferenceBetweenNtpAndSystem}");
}
catch (Exception ex)
{
Debug.WriteLine($"Could not receive time: {ex}");
}
}
public async void SyncTime()
{
_Client = _Client ?? new NtpClient();
try
{
IsBusy = true;
LastError = null;
NtpDateTime = await _Client.RequestTimeAsync();
}
catch (Exception ex)
{
LastError = ex.ToString();
}
finally
{
IsBusy = false;
}
}
public async Task WinRT_NtpClient_DefaultServer_GetsNonNullResponse()
{
var ntpClient = new Yort.Ntp.NtpClient();
try
{
_GotTimeTaskCompletionSource = new TaskCompletionSource <DateTime?>();
ntpClient.TimeReceived += ntpClient_TimeReceived;
ntpClient.ErrorOccurred += NtpClient_ErrorOccurred;
ntpClient.BeginRequestTime();
var result = await _GotTimeTaskCompletionSource.Task;
Assert.AreNotEqual(null, result);
}
finally
{
ntpClient.TimeReceived -= ntpClient_TimeReceived;
}
}
public async Task WinRT_NtpClient_DefaultServer_ClientCanBeReused()
{
int successCount = 0;
var client = new Yort.Ntp.NtpClient();
for (int cnt = 0; cnt < 100; cnt++)
{
try
{
var result = await client.RequestTimeAsync();
successCount++;
Assert.AreNotEqual(DateTime.Now, result.NtpTime);
await Task.Delay(500);
}
catch (NtpNetworkException)
{
}
}
Assert.AreNotEqual(0, successCount);
}
public async void StartTimeSync()
{
ntpClient = new Yort.Ntp.NtpClient(_serverAddress);
_accurateTime = await ntpClient.RequestTimeAsync();
}
public async Task WinRT_NtpClient_DefaultServer_GetAsyncReturnsResponse()
{
var client = new Yort.Ntp.NtpClient();
var currentTime = await client.RequestTimeAsync();
Assert.AreNotEqual(DateTime.Now, currentTime);
}
