private void OnBackgroundInteractiveData(byte[] data) { // WARNING: Only invoke applet state changes after an explicit finalization // request from the game, this is because the inline keyboard is expected to // keep running in the background sending data by itself. using (MemoryStream stream = new MemoryStream(data)) using (BinaryReader reader = new BinaryReader(stream)) { var request = (InlineKeyboardRequest)reader.ReadUInt32(); long remaining; // Always show the keyboard if the state is 'Ready'. bool showKeyboard = _state == SoftwareKeyboardState.Ready; switch (request) { case InlineKeyboardRequest.Unknown0: // Unknown request sent by some games after calc _interactiveSession.Push(InlineResponses.Default()); break; case InlineKeyboardRequest.UseChangedStringV2: // Not used because we only send the entire string after confirmation. _interactiveSession.Push(InlineResponses.Default()); break; case InlineKeyboardRequest.UseMovedCursorV2: // Not used because we only send the entire string after confirmation. _interactiveSession.Push(InlineResponses.Default()); break; case InlineKeyboardRequest.SetCustomizeDic: remaining = stream.Length - stream.Position; if (remaining != Marshal.SizeOf <SoftwareKeyboardDictSet>()) { Logger.Error?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard DictSet of {remaining} bytes!"); } else { var keyboardDictData = reader.ReadBytes((int)remaining); _keyboardDict = ReadStruct <SoftwareKeyboardDictSet>(keyboardDictData); } _interactiveSession.Push(InlineResponses.Default()); break; case InlineKeyboardRequest.Calc: // Put the keyboard in a Ready state, this will force showing _state = SoftwareKeyboardState.Ready; remaining = stream.Length - stream.Position; if (remaining != Marshal.SizeOf <SoftwareKeyboardCalc>()) { Logger.Error?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard Calc of {remaining} bytes!"); } else { var keyboardCalcData = reader.ReadBytes((int)remaining); _keyboardCalc = ReadStruct <SoftwareKeyboardCalc>(keyboardCalcData); if (_keyboardCalc.Utf8Mode == 0x1) { _encoding = Encoding.UTF8; } // Force showing the keyboard regardless of the state, an unwanted // input dialog may show, but it is better than a soft lock. if (_keyboardCalc.Appear.ShouldBeHidden == 0) { showKeyboard = true; } } // Send an initialization finished signal. _interactiveSession.Push(InlineResponses.FinishedInitialize()); // Start a task with the GUI handler to get user's input. new Task(() => { bool submit = true; string inputText = (!string.IsNullOrWhiteSpace(_keyboardCalc.InputText) ? _keyboardCalc.InputText : DefaultText); // Call the configured GUI handler to get user's input. if (!showKeyboard) { // Submit the default text to avoid soft locking if the keyboard was ignored by // accident. It's better to change the name than being locked out of the game. submit = true; inputText = DefaultText; Logger.Debug?.Print(LogClass.Application, "Received a dummy Calc, keyboard will not be shown"); } else if (_device.UiHandler == null) { Logger.Warning?.Print(LogClass.Application, "GUI Handler is not set. Falling back to default"); } else { var args = new SoftwareKeyboardUiArgs { HeaderText = "", // The inline keyboard lacks these texts SubtitleText = "", GuideText = "", SubmitText = (!string.IsNullOrWhiteSpace(_keyboardCalc.Appear.OkText) ? _keyboardCalc.Appear.OkText : "OK"), StringLengthMin = 0, StringLengthMax = 100, InitialText = inputText }; submit = _device.UiHandler.DisplayInputDialog(args, out inputText); } if (submit) { Logger.Debug?.Print(LogClass.ServiceAm, "Sending keyboard OK..."); if (_encoding == Encoding.UTF8) { _interactiveSession.Push(InlineResponses.DecidedEnterUtf8(inputText)); } else { _interactiveSession.Push(InlineResponses.DecidedEnter(inputText)); } } else { Logger.Debug?.Print(LogClass.ServiceAm, "Sending keyboard Cancel..."); _interactiveSession.Push(InlineResponses.DecidedCancel()); } // TODO: Why is this necessary? Does the software expect a constant stream of responses? Thread.Sleep(500); Logger.Debug?.Print(LogClass.ServiceAm, "Resetting state of the keyboard..."); _interactiveSession.Push(InlineResponses.Default()); }).Start(); break; case InlineKeyboardRequest.Finalize: // The game wants to close the keyboard applet and will wait for a state change. _state = SoftwareKeyboardState.Uninitialized; AppletStateChanged?.Invoke(this, null); break; default: // We shouldn't be able to get here through standard swkbd execution. Logger.Error?.Print(LogClass.ServiceAm, $"Invalid Software Keyboard request {request} during state {_state}!"); _interactiveSession.Push(InlineResponses.Default()); break; } } }
private void Execute() { string initialText = null; // Initial Text is always encoded as a UTF-16 string in the work buffer (passed as transfer memory) // InitialStringOffset points to the memory offset and InitialStringLength is the number of UTF-16 characters if (_transferMemory != null && _keyboardConfig.InitialStringLength > 0) { initialText = Encoding.Unicode.GetString(_transferMemory, _keyboardConfig.InitialStringOffset, 2 * _keyboardConfig.InitialStringLength); } // If the max string length is 0, we set it to a large default // length. if (_keyboardConfig.StringLengthMax == 0) { _keyboardConfig.StringLengthMax = 100; } var args = new SoftwareKeyboardUiArgs { HeaderText = _keyboardConfig.HeaderText, SubtitleText = _keyboardConfig.SubtitleText, GuideText = _keyboardConfig.GuideText, SubmitText = (!string.IsNullOrWhiteSpace(_keyboardConfig.SubmitText) ? _keyboardConfig.SubmitText : "OK"), StringLengthMin = _keyboardConfig.StringLengthMin, StringLengthMax = _keyboardConfig.StringLengthMax, InitialText = initialText }; // Call the configured GUI handler to get user's input if (_device.UiHandler == null) { Logger.Warning?.Print(LogClass.Application, $"GUI Handler is not set. Falling back to default"); _okPressed = true; } else { _okPressed = _device.UiHandler.DisplayInputDialog(args, out _textValue); } _textValue ??= initialText ?? DefaultText; // If the game requests a string with a minimum length less // than our default text, repeat our default text until we meet // the minimum length requirement. // This should always be done before the text truncation step. while (_textValue.Length < _keyboardConfig.StringLengthMin) { _textValue = String.Join(" ", _textValue, _textValue); } // If our default text is longer than the allowed length, // we truncate it. if (_textValue.Length > _keyboardConfig.StringLengthMax) { _textValue = _textValue.Substring(0, (int)_keyboardConfig.StringLengthMax); } // Does the application want to validate the text itself? if (_keyboardConfig.CheckText) { // The application needs to validate the response, so we // submit it to the interactive output buffer, and poll it // for validation. Once validated, the application will submit // back a validation status, which is handled in OnInteractiveDataPushIn. _state = SoftwareKeyboardState.ValidationPending; _interactiveSession.Push(BuildResponse(_textValue, true)); } else { // If the application doesn't need to validate the response, // we push the data to the non-interactive output buffer // and poll it for completion. _state = SoftwareKeyboardState.Complete; _normalSession.Push(BuildResponse(_textValue, false)); AppletStateChanged?.Invoke(this, null); } }
private void GetInputTextAndSend(bool shouldShowKeyboard, InlineKeyboardState oldState) { bool submit = true; // Use the text specified by the Calc if it is available, otherwise use the default one. string inputText = (!string.IsNullOrWhiteSpace(_keyboardBackgroundCalc.InputText) ? _keyboardBackgroundCalc.InputText : DefaultText); // Compute the elapsed time for the debouncing algorithm. long currentMillis = PerformanceCounter.ElapsedMilliseconds; long inputElapsedMillis = currentMillis - _lastTextSetMillis; // Reset the input text before submitting the final result, that's because some games do not expect // consecutive submissions to abruptly shrink and they will crash if it happens. Changing the string // before the final submission prevents that. InlineKeyboardState newState = InlineKeyboardState.DataAvailable; SetInlineState(newState); ChangedString("", newState); if (!_lastWasHidden && (inputElapsedMillis < DebounceTimeMillis)) { // A repeated Calc request has been received without player interaction, after the input has been // sent. This behavior happens in some games, so instead of showing another dialog, just apply a // time-based debouncing algorithm and repeat the last submission, either a value or a cancel. // It is also possible that the first Calc request was hidden by accident, in this case use the // debouncing as an oportunity to properly ask for input. inputText = _textValue; submit = _textValue != null; _lastWasHidden = false; Logger.Warning?.Print(LogClass.Application, "Debouncing repeated keyboard request"); } else if (!shouldShowKeyboard) { // Submit the default text to avoid soft locking if the keyboard was ignored by // accident. It's better to change the name than being locked out of the game. inputText = DefaultText; _lastWasHidden = true; Logger.Debug?.Print(LogClass.Application, "Received a dummy Calc, keyboard will not be shown"); } else if (_device.UiHandler == null) { Logger.Warning?.Print(LogClass.Application, "GUI Handler is not set. Falling back to default"); _lastWasHidden = false; } else { // Call the configured GUI handler to get user's input. var args = new SoftwareKeyboardUiArgs { HeaderText = "", // The inline keyboard lacks these texts SubtitleText = "", GuideText = "", SubmitText = (!string.IsNullOrWhiteSpace(_keyboardBackgroundCalc.Appear.OkText) ? _keyboardBackgroundCalc.Appear.OkText : "OK"), StringLengthMin = 0, StringLengthMax = 100, InitialText = inputText }; submit = _device.UiHandler.DisplayInputDialog(args, out inputText); inputText = submit ? inputText : null; _lastWasHidden = false; } // The 'Complete' state indicates the Calc request has been fulfilled by the applet. newState = InlineKeyboardState.Complete; if (submit) { Logger.Debug?.Print(LogClass.ServiceAm, "Sending keyboard OK"); DecidedEnter(inputText, newState); } else { Logger.Debug?.Print(LogClass.ServiceAm, "Sending keyboard Cancel"); DecidedCancel(newState); } _interactiveSession.Push(InlineResponses.Default(newState)); // The constant calls to PopInteractiveData suggest that the keyboard applet continuously reports // data back to the application and this can also be time-sensitive. Pushing a state reset right // after the data has been sent does not work properly and the application will soft-lock. This // delay gives time for the application to catch up with the data and properly process the state // reset. Thread.Sleep(ResetDelayMillis); // 'Initialized' is the only known state so far that does not soft-lock the keyboard after use. newState = InlineKeyboardState.Initialized; Logger.Debug?.Print(LogClass.ServiceAm, $"Resetting state of the keyboard to {newState}"); SetInlineState(newState); _interactiveSession.Push(InlineResponses.Default(newState)); // Keep the text and the timestamp of the input for the debouncing algorithm. _textValue = inputText; _lastTextSetMillis = PerformanceCounter.ElapsedMilliseconds; }