Artemis.DeviceProviders.KeyboardProvider.CanEnableAsync C# (CSharp) Метод

        public Task<bool> CanEnableAsync(ProgressDialogController dialog)
        {
            return Task.Run(() =>
            {
                for (var tries = 1; tries <= 10; tries++)
                {
                    // Dialog interaction
                    if (dialog != null)
                    {
                        // Stop if cancelled by user
                        if (dialog.IsCanceled)
                        {
                            dialog.SetIndeterminate();
                            return false;
                        }
                        // Updated progress to indicate how much tries are left
                        dialog.SetProgress(0.1*tries);
                    }

                    if (CanEnable())
                    {
                        dialog?.SetIndeterminate();
                        return true;
                    }
                    Thread.Sleep(2000);
                }
                dialog?.SetIndeterminate();
                return false;
            });
        }

        /// <summary>
        ///     Enables the given keyboard
        /// </summary>
        /// <param name="keyboardProvider"></param>
        public async void EnableKeyboard(KeyboardProvider keyboardProvider)
        {
            if (keyboardProvider == null)
                throw new ArgumentNullException(nameof(keyboardProvider));

            if (ChangingKeyboard || (ActiveKeyboard?.Name == keyboardProvider.Name))
                return;

            _logger.Debug("Trying to enable keyboard: {0}", keyboardProvider.Name);
            ChangingKeyboard = true;

            // Store the old keyboard so it can be used in the event we're raising later
            var oldKeyboard = ActiveKeyboard;

            // Release the current keyboard
            ReleaseActiveKeyboard();

            // Create a dialog to let the user know Artemis hasn't frozen
            ProgressDialogController dialog = null;
            if (DialogService.GetActiveWindow() != null)
            {
                dialog = await DialogService.ShowProgressDialog("Enabling keyboard",
                    $"Checking if keyboard '{keyboardProvider.Name}' can be enabled...", true);

                // May seem a bit cheesy, but it's tidier to have the animation finish
                await Task.Delay(500);
            }
            dialog?.SetIndeterminate();

            var canEnable = await keyboardProvider.CanEnableAsync(dialog);
            if (!canEnable)
            {
                if (dialog != null)
                    await dialog.CloseAsync();

                DialogService.ShowErrorMessageBox(keyboardProvider.CantEnableText);
                ActiveKeyboard = null;
                _generalSettings.LastKeyboard = null;
                _generalSettings.Save();
                _logger.Warn("Failed enabling keyboard: {0}", keyboardProvider.Name);
                ChangingKeyboard = false;
                return;
            }

            dialog?.SetMessage($"Enabling keyboard: {keyboardProvider.Name}...");

            // Setup the new keyboard
            ActiveKeyboard = keyboardProvider;
            await ActiveKeyboard.EnableAsync(dialog);
            EnableUsableDevices();

            _generalSettings.LastKeyboard = ActiveKeyboard.Name;
            _generalSettings.Save();

            RaiseKeyboardChangedEvent(new KeyboardChangedEventArgs(oldKeyboard, ActiveKeyboard));
            _logger.Debug("Enabled keyboard: {0}", keyboardProvider.Name);

            if (dialog != null)
                await dialog.CloseAsync();

            ChangingKeyboard = false;
        }