/// <summary>
/// Асинхронная смена сценария
/// </summary>
/// <returns></returns>
private async Task ChangeScenarioAsync(string fileName, bool isQuickLoad)
{
if (isQuickLoad)
{
mFileName = fileName;
await ProgressDialogService.ExecuteAsync(LoadAsync).ConfigureAwait(false);
}
else
{
await TaskExtension.Delay(1).ConfigureAwait(false);
var dialog = new OpenFileDialog {
Filter = "Файл с описанием сценария (xmlinfo)|*.xmlinfo"
};
if (!string.IsNullOrEmpty(DataHolder.Instance.FullFolderPath))
{
dialog.InitialDirectory = DataHolder.Instance.FullFolderPath;
dialog.FileName = Path.Combine(DataHolder.Instance.FullFolderPath, Constants.cScenarioDescriptor);
}
if (dialog.ShowDialog() == true)
{
mFileName = dialog.FileName;
await ProgressDialogService.ExecuteAsync(LoadAsync).ConfigureAwait(false);
}
}
}
//private void OnIpAddressChanged(object sender, TextChangedEventArgs e)
//{
// Preferences.Set("ip_address", e.NewTextValue);
//}
private async void ConnectToDevice(ConnectionPayload payload)
{
ClientConnection.Instance.Connect(payload);
try
{
await TaskExtension.WaitUntil(() => ClientConnection.Instance.IsConnected, timeout : 5000);
}
catch (TimeoutException e)
{
Console.WriteLine("Connection timed out");
}
if (ClientConnection.Instance.IsConnected)
{
await SecureStorage.SetAsync("connection_payload", JsonConvert.SerializeObject(payload));
await DisplayAlert("Success!", "You are connected to your device", "OK");
await Navigation.PushAsync(new ItemsPage(), true);
}
else
{
await DisplayAlert("Error!", "Failed connecting to your device", "OK");
SecureStorage.Remove("connection_payload");
}
}
public Task WaitOperationsAsync(TimeSpan timeout)
{
lock (this)
{
return(TaskExtension.GetCompletedTask());
}
}
public Task ClearPendingLogState(string channelName)
{
lock (this)
{
return(TaskExtension.GetCompletedTask());
}
}
public Task <int> CountLogsAsync(string channelName)
{
lock (this)
{
return(TaskExtension.GetCompletedTask(this[channelName].Count));
}
}
public Task <bool> SetMaxStorageSizeAsync(long sizeInBytes)
{
lock (this)
{
return(TaskExtension.GetCompletedTask(true));
}
}
public Task <bool> ShutdownAsync(TimeSpan timeout)
{
lock (this)
{
return(TaskExtension.GetCompletedTask(true));
}
}
public void Start()
{
#if NET40
TaskExtension.Run(() => TryProcessQueuedApplicationMessagesAsync(_cancellationToken).Wait(), _cancellationToken).Forget(_logger);
#else
Task.Run(() => TryProcessQueuedApplicationMessagesAsync(_cancellationToken), _cancellationToken).Forget(_logger);
#endif
}
public Task DeleteLogs(string channelName)
{
lock (this)
{
_storage.Remove(channelName);
return(TaskExtension.GetCompletedTask());
}
}
public TaskExtension NewTaskExtension(TaskExtension extension)
{
var obj = extension.GetTableObject();
var taskExtensionId = m_db.Insert("TaskExtensions", "task_extension_id", true, obj);
extension.TaskExtensionId = (int)taskExtensionId;
return(extension);
}
public Task PutLog(string channelName, Log log)
{
lock (this)
{
this[channelName].Add(log);
return(TaskExtension.GetCompletedTask());
}
}
private Task GenerateOnceTask(Dictionary <string, DateTime> timeDictionary, int projectId, int moduleId, TemplateTask templateTask, Dictionary <int, List <Tuple <int, string> > > taskDependency, int index)
{
Task task = new Task();
task.TemplateTaskId = templateTask.TemplateTaskId;
task.ProjectId = projectId;
task.TaskModuleId = moduleId.ToString();
task.Description = templateTask.TemplateTaskName;
var realDate = DateUtils.ParseDateSyntax(templateTask.TriggerDate, timeDictionary);
task.EndTime = realDate;
if (!string.IsNullOrEmpty(templateTask.BeginDate))
{
task.StartTime = DateUtils.ParseDateSyntax(templateTask.BeginDate, timeDictionary);
}
task.TaskStatus = (DateTime.Today <= task.EndTime) ? TaskStatus.Waitting : TaskStatus.Overdue;;
task.TaskDetail = templateTask.TemplateTaskDetail;
task.TaskTarget = templateTask.TemplateTaskTarget;
foreach (var prevId in templateTask.PrevIds)
{
if (index == -1)
{
var prevTaskIds = taskDependency[prevId].ConvertAll(x => x.Item1.ToString()).ToArray();
if (!string.IsNullOrEmpty(task.PreTaskIds))
{
task.PreTaskIds += CommUtils.Spliter;
}
task.PreTaskIds += CommUtils.Join(prevTaskIds);
}
else
{
var prevTaskId = taskDependency[prevId][index].Item1;
if (!string.IsNullOrEmpty(task.PreTaskIds))
{
task.PreTaskIds += CommUtils.Spliter;
}
task.PreTaskIds += prevTaskId;
}
}
if (!string.IsNullOrEmpty(templateTask.TemplateTaskExtensionName))
{
var extensionType = templateTask.TemplateTaskExtensionName;
var extension = new TaskExtension {
TaskExtensionName = extensionType,
TaskExtensionType = extensionType,
TaskExtensionStatus = 0
};
extension = NewTaskExtension(extension);
task.TaskExtensionId = extension.TaskExtensionId;
}
var newTask = NewTask(task);
return(newTask);
}
public Task PutLog(string channelName, Log log)
{
lock (this)
{
AppCenterLog.Debug(AppCenterLog.LogTag, $"Storage.PutLog for channelName={channelName}: {log}");
this[channelName].Add(log);
return(TaskExtension.GetCompletedTask());
}
}
public Task DeleteLogs(string channelName)
{
lock (this)
{
AppCenterLog.Debug(AppCenterLog.LogTag, $"Storage.DeleteLogs for channelName={channelName}");
_storage.Remove(channelName);
return(TaskExtension.GetCompletedTask());
}
}
public Task DeleteLogs(string channelName, string batchId)
{
lock (this)
{
var batch = _pending[batchId];
this[channelName].RemoveAll(log => batch.Contains(log));
return(TaskExtension.GetCompletedTask());
}
}
public Task DeleteLogs(string channelName, string batchId)
{
lock (this)
{
AppCenterLog.Debug(AppCenterLog.LogTag, $"Storage.DeleteLogs for channelName={channelName} and batchId={batchId}");
var batch = _pending[batchId];
this[channelName].RemoveAll(log => batch.Contains(log));
return(TaskExtension.GetCompletedTask());
}
}
Task OnClientAcceptedAsync(IMqttChannelAdapter channelAdapter)
{
var clientHandler = ClientHandler;
if (clientHandler == null)
{
return(TaskExtension.FromResult(0));
}
return(clientHandler(channelAdapter));
}
public void ResetStatsButton_Pressed()
{
PopupManager.Get().NewQuestion(PopupType.Warning, "", "Reset Your Local and Server Stats?", (PopupQuestionResult result) =>
{
if (result == PopupQuestionResult.Accept)
{
PlayerPrefs.DeleteAll();
StartCoroutine(TaskExtension.YieldWait(UserDatabase.Get().PostUserHighScore(0)));
}
});
}
async Task TrySendKeepAliveMessagesAsync(CancellationToken cancellationToken)
{
try
{
_logger.Verbose("Start sending keep alive packets.");
var keepAlivePeriod = Options.KeepAlivePeriod;
while (!cancellationToken.IsCancellationRequested)
{
// Values described here: [MQTT-3.1.2-24].
var waitTime = keepAlivePeriod - _sendTracker.Elapsed;
if (waitTime <= TimeSpan.Zero)
{
await SendAndReceiveAsync <MqttPingRespPacket>(new MqttPingReqPacket(), cancellationToken).ConfigureAwait(false);
}
// Wait a fixed time in all cases. Calculation of the remaining time is complicated
// due to some edge cases and was buggy in the past. Now we wait half a second because the
// min keep alive value is one second so that the server will wait 1.5 seconds for a PING
// packet.
await TaskExtension.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false);
}
}
catch (Exception exception)
{
if (_cleanDisconnectInitiated)
{
return;
}
if (exception is OperationCanceledException)
{
}
else if (exception is MqttCommunicationException)
{
_logger.Warning(exception, "Communication error while sending/receiving keep alive packets.");
}
else
{
_logger.Error(exception, "Error exception while sending/receiving keep alive packets.");
}
if (!DisconnectIsPending())
{
await DisconnectInternalAsync(_keepAlivePacketsSenderTask, exception, null).ConfigureAwait(false);
}
}
finally
{
_logger.Verbose("Stopped sending keep alive packets.");
}
}
public Task <string> GetLogsAsync(string channelName, int limit, List <Log> logs)
{
lock (this)
{
var batchId = Guid.NewGuid().ToString();
var batch = this[channelName].Take(limit).ToList();
_pending.Add(batchId, batch);
logs?.Clear();
logs?.AddRange(batch);
return(TaskExtension.GetCompletedTask(batchId));
}
}
public void Start(int keepAlivePeriod, CancellationToken cancellationToken)
{
if (keepAlivePeriod == 0)
{
return;
}
#if NET40
TaskExtension.Run(() => RunAsync(keepAlivePeriod, cancellationToken).Wait(), cancellationToken).Forget(_logger);
#else
Task.Run(() => RunAsync(keepAlivePeriod, cancellationToken), cancellationToken).Forget(_logger);
#endif
}
public MqttServerClientUnsubscribedTopicHandlerDelegate(Action <MqttServerClientUnsubscribedTopicEventArgs> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
_handler = eventArgs =>
{
handler(eventArgs);
return(TaskExtension.FromResult(0));
};
}
public MqttServerStartedHandlerDelegate(Action <EventArgs> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
_handler = eventArgs =>
{
handler(eventArgs);
return(TaskExtension.FromResult(0));
};
}
public MqttApplicationMessageReceivedHandlerDelegate(Action <MqttApplicationMessageReceivedEventArgs> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
_handler = context =>
{
handler(context);
return(TaskExtension.FromResult(0));
};
}
public MqttServerApplicationMessageInterceptorDelegate(Action <MqttApplicationMessageInterceptorContext> callback)
{
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
_callback = context =>
{
callback(context);
return(TaskExtension.FromResult(0));
};
}
public MqttClientDisconnectedHandlerDelegate(Action <MqttClientDisconnectedEventArgs> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
_handler = context =>
{
handler(context);
return(TaskExtension.FromResult(0));
};
}
public MqttServerConnectionValidatorDelegate(Action <MqttConnectionValidatorContext> callback)
{
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
_callback = context =>
{
callback(context);
return(TaskExtension.FromResult(0));
};
}
public TaskExtension GetTaskExtension(int taskExtensionId)
{
var taskExtensions = m_db.Query <ABSMgrConn.TableTaskExtensions>(
"SELECT * FROM dbo.TaskExtensions WHERE dbo.TaskExtensions.task_extension_id = @0", taskExtensionId);
if (taskExtensions.Count() != 1)
{
throw new ApplicationException("Get taskExtension [" + taskExtensionId + "] failed.");
}
var taskExtension = new TaskExtension(taskExtensions.Single());
return(taskExtension);
}
public Task <IList <IMqttSessionStatus> > GetSessionStatusAsync()
{
var result = new List <IMqttSessionStatus>();
foreach (var session in _sessions.Values)
{
var sessionStatus = new MqttSessionStatus(session, this);
session.FillStatus(sessionStatus);
result.Add(sessionStatus);
}
return(TaskExtension.FromResult((IList <IMqttSessionStatus>)result));
}
public Task <string> GetLogsAsync(string channelName, int limit, List <Log> logs)
{
lock (this)
{
var pending = _pending.SelectMany(i => i.Value).ToList();
var batchId = Guid.NewGuid().ToString();
var batch = this[channelName]
.Where(log => !pending.Contains(log))
.Take(limit).ToList();
_pending.Add(batchId, batch);
logs?.Clear();
logs?.AddRange(batch);
return(TaskExtension.GetCompletedTask(batchId));
}
}
