Merge pull request #1667 from DarkLordZach/swkbd

am: Implement HLE software keyboard applet

4 files changed, 439 insertions, 0 deletions

diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp
new file mode 100644
index 000000000..8adb81823
--- /dev/null
+++ b/src/core/hle/service/am/applets/applets.cpp
@@ -0,0 +1,115 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/assert.h"
+#include "core/core.h"
+#include "core/hle/kernel/event.h"
+#include "core/hle/kernel/server_port.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+AppletDataBroker::AppletDataBroker() {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    state_changed_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                "ILibraryAppletAccessor:StateChangedEvent");
+    pop_out_data_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                               "ILibraryAppletAccessor:PopDataOutEvent");
+    pop_interactive_out_data_event = Kernel::Event::Create(
+        kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
+}
+
+AppletDataBroker::~AppletDataBroker() = default;
+
+std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToGame() {
+    if (out_channel.empty())
+        return nullptr;
+
+    auto out = std::move(out_channel.front());
+    out_channel.pop();
+    return out;
+}
+
+std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToApplet() {
+    if (in_channel.empty())
+        return nullptr;
+
+    auto out = std::move(in_channel.front());
+    in_channel.pop();
+    return out;
+}
+
+std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToGame() {
+    if (out_interactive_channel.empty())
+        return nullptr;
+
+    auto out = std::move(out_interactive_channel.front());
+    out_interactive_channel.pop();
+    return out;
+}
+
+std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToApplet() {
+    if (in_interactive_channel.empty())
+        return nullptr;
+
+    auto out = std::move(in_interactive_channel.front());
+    in_interactive_channel.pop();
+    return out;
+}
+
+void AppletDataBroker::PushNormalDataFromGame(IStorage storage) {
+    in_channel.push(std::make_unique<IStorage>(storage));
+}
+
+void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) {
+    out_channel.push(std::make_unique<IStorage>(storage));
+    pop_out_data_event->Signal();
+}
+
+void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
+    in_interactive_channel.push(std::make_unique<IStorage>(storage));
+}
+
+void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) {
+    out_interactive_channel.push(std::make_unique<IStorage>(storage));
+    pop_interactive_out_data_event->Signal();
+}
+
+void AppletDataBroker::SignalStateChanged() const {
+    state_changed_event->Signal();
+}
+
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetNormalDataEvent() const {
+    return pop_out_data_event;
+}
+
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetInteractiveDataEvent() const {
+    return pop_interactive_out_data_event;
+}
+
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetStateChangedEvent() const {
+    return state_changed_event;
+}
+
+Applet::Applet() = default;
+
+Applet::~Applet() = default;
+
+void Applet::Initialize(std::shared_ptr<AppletDataBroker> broker_) {
+    broker = std::move(broker_);
+
+    const auto common = broker->PopNormalDataToApplet();
+    ASSERT(common != nullptr);
+
+    const auto common_data = common->GetData();
+
+    ASSERT(common_data.size() >= sizeof(CommonArguments));
+    std::memcpy(&common_args, common_data.data(), sizeof(CommonArguments));
+
+    initialized = true;
+}
+
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h
new file mode 100644
index 000000000..136445649
--- /dev/null
+++ b/src/core/hle/service/am/applets/applets.h
@@ -0,0 +1,94 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <queue>
+#include "common/swap.h"
+#include "core/hle/kernel/event.h"
+
+union ResultCode;
+
+namespace Service::AM {
+
+class IStorage;
+
+namespace Applets {
+
+class AppletDataBroker final {
+public:
+    AppletDataBroker();
+    ~AppletDataBroker();
+
+    std::unique_ptr<IStorage> PopNormalDataToGame();
+    std::unique_ptr<IStorage> PopNormalDataToApplet();
+
+    std::unique_ptr<IStorage> PopInteractiveDataToGame();
+    std::unique_ptr<IStorage> PopInteractiveDataToApplet();
+
+    void PushNormalDataFromGame(IStorage storage);
+    void PushNormalDataFromApplet(IStorage storage);
+
+    void PushInteractiveDataFromGame(IStorage storage);
+    void PushInteractiveDataFromApplet(IStorage storage);
+
+    void SignalStateChanged() const;
+
+    Kernel::SharedPtr<Kernel::Event> GetNormalDataEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetInteractiveDataEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetStateChangedEvent() const;
+
+private:
+    // Queues are named from applet's perspective
+    std::queue<std::unique_ptr<IStorage>>
+        in_channel; // PopNormalDataToApplet and PushNormalDataFromGame
+    std::queue<std::unique_ptr<IStorage>>
+        out_channel; // PopNormalDataToGame and PushNormalDataFromApplet
+    std::queue<std::unique_ptr<IStorage>>
+        in_interactive_channel; // PopInteractiveDataToApplet and PushInteractiveDataFromGame
+    std::queue<std::unique_ptr<IStorage>>
+        out_interactive_channel; // PopInteractiveDataToGame and PushInteractiveDataFromApplet
+
+    Kernel::SharedPtr<Kernel::Event> state_changed_event;
+    Kernel::SharedPtr<Kernel::Event> pop_out_data_event; // Signaled on PushNormalDataFromApplet
+    Kernel::SharedPtr<Kernel::Event>
+        pop_interactive_out_data_event; // Signaled on PushInteractiveDataFromApplet
+};
+
+class Applet {
+public:
+    Applet();
+    virtual ~Applet();
+
+    virtual void Initialize(std::shared_ptr<AppletDataBroker> broker);
+
+    virtual bool TransactionComplete() const = 0;
+    virtual ResultCode GetStatus() const = 0;
+    virtual void ExecuteInteractive() = 0;
+    virtual void Execute() = 0;
+
+    bool IsInitialized() const {
+        return initialized;
+    }
+
+protected:
+    struct CommonArguments {
+        u32_le arguments_version;
+        u32_le size;
+        u32_le library_version;
+        u32_le theme_color;
+        u8 play_startup_sound;
+        u64_le system_tick;
+    };
+    static_assert(sizeof(CommonArguments) == 0x20, "CommonArguments has incorrect size.");
+
+    CommonArguments common_args;
+    std::shared_ptr<AppletDataBroker> broker;
+    bool initialized = false;
+};
+
+} // namespace Applets
+} // namespace Service::AM
diff --git a/src/core/hle/service/am/applets/software_keyboard.cpp b/src/core/hle/service/am/applets/software_keyboard.cpp
new file mode 100644
index 000000000..c4b76a515
--- /dev/null
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -0,0 +1,161 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/assert.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
+
+namespace Service::AM::Applets {
+
+constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
+constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
+constexpr std::size_t DEFAULT_MAX_LENGTH = 500;
+constexpr bool INTERACTIVE_STATUS_OK = false;
+
+static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
+    KeyboardConfig config, std::u16string initial_text) {
+    Core::Frontend::SoftwareKeyboardParameters params{};
+
+    params.submit_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(
+        config.submit_text.data(), config.submit_text.size());
+    params.header_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(
+        config.header_text.data(), config.header_text.size());
+    params.sub_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(config.sub_text.data(),
+                                                                       config.sub_text.size());
+    params.guide_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(config.guide_text.data(),
+                                                                         config.guide_text.size());
+    params.initial_text = initial_text;
+    params.max_length = config.length_limit == 0 ? DEFAULT_MAX_LENGTH : config.length_limit;
+    params.password = static_cast<bool>(config.is_password);
+    params.cursor_at_beginning = static_cast<bool>(config.initial_cursor_position);
+    params.value = static_cast<u8>(config.keyset_disable_bitmask);
+
+    return params;
+}
+
+SoftwareKeyboard::SoftwareKeyboard() = default;
+
+SoftwareKeyboard::~SoftwareKeyboard() = default;
+
+void SoftwareKeyboard::Initialize(std::shared_ptr<AppletDataBroker> broker_) {
+    complete = false;
+    initial_text.clear();
+    final_data.clear();
+
+    Applet::Initialize(std::move(broker_));
+
+    const auto keyboard_config_storage = broker->PopNormalDataToApplet();
+    ASSERT(keyboard_config_storage != nullptr);
+    const auto& keyboard_config = keyboard_config_storage->GetData();
+
+    ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
+    std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
+
+    const auto work_buffer_storage = broker->PopNormalDataToApplet();
+    ASSERT(work_buffer_storage != nullptr);
+    const auto& work_buffer = work_buffer_storage->GetData();
+
+    if (config.initial_string_size == 0)
+        return;
+
+    std::vector<char16_t> string(config.initial_string_size);
+    std::memcpy(string.data(), work_buffer.data() + config.initial_string_offset,
+                string.size() * 2);
+    initial_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size());
+}
+
+bool SoftwareKeyboard::TransactionComplete() const {
+    return complete;
+}
+
+ResultCode SoftwareKeyboard::GetStatus() const {
+    return RESULT_SUCCESS;
+}
+
+void SoftwareKeyboard::ExecuteInteractive() {
+    if (complete)
+        return;
+
+    const auto storage = broker->PopInteractiveDataToApplet();
+    ASSERT(storage != nullptr);
+    const auto data = storage->GetData();
+    const auto status = static_cast<bool>(data[0]);
+
+    if (status == INTERACTIVE_STATUS_OK) {
+        complete = true;
+    } else {
+        const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
+        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+        frontend.SendTextCheckDialog(
+            Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+            [this] { broker->SignalStateChanged(); });
+    }
+}
+
+void SoftwareKeyboard::Execute() {
+    if (complete) {
+        broker->PushNormalDataFromApplet(IStorage{final_data});
+        return;
+    }
+
+    const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
+
+    const auto parameters = ConvertToFrontendParameters(config, initial_text);
+
+    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(text); },
+                         parameters);
+}
+
+void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
+    std::vector<u8> output_main(SWKBD_OUTPUT_BUFFER_SIZE);
+
+    if (text.has_value()) {
+        std::vector<u8> output_sub(SWKBD_OUTPUT_BUFFER_SIZE);
+
+        if (config.utf_8) {
+            const u64 size = text->size() + 8;
+            const auto new_text = Common::UTF16ToUTF8(*text);
+
+            std::memcpy(output_sub.data(), &size, sizeof(u64));
+            std::memcpy(output_sub.data() + 8, new_text.data(),
+                        std::min(new_text.size(), SWKBD_OUTPUT_BUFFER_SIZE - 8));
+
+            output_main[0] = INTERACTIVE_STATUS_OK;
+            std::memcpy(output_main.data() + 4, new_text.data(),
+                        std::min(new_text.size(), SWKBD_OUTPUT_BUFFER_SIZE - 4));
+        } else {
+            const u64 size = text->size() * 2 + 8;
+            std::memcpy(output_sub.data(), &size, sizeof(u64));
+            std::memcpy(output_sub.data() + 8, text->data(),
+                        std::min(text->size() * 2, SWKBD_OUTPUT_BUFFER_SIZE - 8));
+
+            output_main[0] = INTERACTIVE_STATUS_OK;
+            std::memcpy(output_main.data() + 4, text->data(),
+                        std::min(text->size() * 2, SWKBD_OUTPUT_BUFFER_SIZE - 4));
+        }
+
+        complete = !config.text_check;
+        final_data = output_main;
+
+        if (complete) {
+            broker->PushNormalDataFromApplet(IStorage{output_main});
+        } else {
+            broker->PushInteractiveDataFromApplet(IStorage{output_sub});
+        }
+
+        broker->SignalStateChanged();
+    } else {
+        output_main[0] = 1;
+        complete = true;
+        broker->PushNormalDataFromApplet(IStorage{output_main});
+        broker->SignalStateChanged();
+    }
+}
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/software_keyboard.h b/src/core/hle/service/am/applets/software_keyboard.h
new file mode 100644
index 000000000..16e1fff66
--- /dev/null
+++ b/src/core/hle/service/am/applets/software_keyboard.h
@@ -0,0 +1,69 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+enum class KeysetDisable : u32 {
+    Space = 0x02,
+    Address = 0x04,
+    Percent = 0x08,
+    Slashes = 0x10,
+    Numbers = 0x40,
+    DownloadCode = 0x80,
+};
+
+struct KeyboardConfig {
+    INSERT_PADDING_BYTES(4);
+    std::array<char16_t, 9> submit_text;
+    u16_le left_symbol_key;
+    u16_le right_symbol_key;
+    INSERT_PADDING_BYTES(1);
+    KeysetDisable keyset_disable_bitmask;
+    u32_le initial_cursor_position;
+    std::array<char16_t, 65> header_text;
+    std::array<char16_t, 129> sub_text;
+    std::array<char16_t, 257> guide_text;
+    u32_le length_limit;
+    INSERT_PADDING_BYTES(4);
+    u32_le is_password;
+    INSERT_PADDING_BYTES(5);
+    bool utf_8;
+    bool draw_background;
+    u32_le initial_string_offset;
+    u32_le initial_string_size;
+    u32_le user_dictionary_offset;
+    u32_le user_dictionary_size;
+    bool text_check;
+    u64_le text_check_callback;
+};
+static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect size.");
+
+class SoftwareKeyboard final : public Applet {
+public:
+    SoftwareKeyboard();
+    ~SoftwareKeyboard() override;
+
+    void Initialize(std::shared_ptr<AppletDataBroker> broker) override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    void WriteText(std::optional<std::u16string> text);
+
+private:
+    KeyboardConfig config;
+    std::u16string initial_text;
+    bool complete = false;
+    std::vector<u8> final_data;
+};
+
+} // namespace Service::AM::Applets