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