/// <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)); } }