citra-emu
/
citra-nightly
Archived
1
0
Fork 0
Code

frontend/applets: misc fixes 

* Renamed applet to applets

* Added log classes Applet and Applet.SWKBD

* Fixes to get it compile
This commit is contained in:
zhupengfei 2018-06-20 12:01:54 +08:00
parent caacefcc2e
commit 18664c719e
No known key found for this signature in database
GPG Key ID: 85B82A3E62174206
9 changed files with 147 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/logging/backend.cpp
View File

@ -158,6 +158,8 @@ void FileBackend::Write(const Entry& entry) {
SUB(Debug, GDBStub) \
CLS(Kernel) \
SUB(Kernel, SVC) \
CLS(Applet) \
SUB(Applet, SWKBD) \
CLS(Service) \
SUB(Service, SRV) \
SUB(Service, FRD) \

3
src/common/logging/log.h
View File

@ -48,6 +48,9 @@ enum class Class : ClassType {
Debug_GDBStub, ///< GDB Stub
Kernel, ///< The HLE implementation of the CTR kernel
Kernel_SVC, ///< Kernel system calls
Applet, ///< HLE implementation of system applets. Each applet
/// should have its own subclass.
Applet_SWKBD, ///< The Software Keyboard applet
Service, ///< HLE implementation of system services. Each major service
/// should have its own subclass.
Service_SRV, ///< The SRV (Service Directory) implementation

8
src/core/CMakeLists.txt
View File

@ -68,10 +68,10 @@ add_library(core STATIC
file_sys/savedata_archive.h
file_sys/title_metadata.cpp
file_sys/title_metadata.h
frontend/applet/interface.cpp
frontend/applet/interface.h
frontend/applet/swkbd.cpp
frontend/applet/swkbd.h
frontend/applets/interface.cpp
frontend/applets/interface.h
frontend/applets/swkbd.cpp
frontend/applets/swkbd.h
frontend/camera/blank_camera.cpp
frontend/camera/blank_camera.h
frontend/camera/factory.cpp

6
src/core/frontend/applet/interface.cpp → src/core/frontend/applets/interface.cpp
View File

@ -3,7 +3,7 @@
// Refer to the license.txt file included.
#include <unordered_map>
#include "core/frontend/interface.h"
#include "core/frontend/applets/interface.h"
namespace Frontend {
@ -17,4 +17,8 @@ void UnregisterFrontendApplet(AppletType type) {
registered_applets.erase(type);
}
std::shared_ptr<AppletInterface> GetRegisteredApplet(AppletType type) {
return registered_applets.at(type);
}
} // namespace Frontend

19
src/core/frontend/applet/interface.h → src/core/frontend/applets/interface.h
View File

@ -16,6 +16,7 @@ enum class AppletType {
class AppletConfig {};
class AppletData {};
// TODO(jroweboy) add ability to draw to framebuffer
class AppletInterface {
public:
virtual ~AppletInterface() = default;
@ -24,12 +25,7 @@ public:
* On applet start, the applet specific configuration will be passed in along with the
* framebuffer.
*/
// virtual void Setup(const Config* /*, framebuffer */) = 0;
/**
* Called on a fixed schedule to have the applet update any state such as the framebuffer.
*/
virtual void Update() = 0;
virtual void Setup(const AppletConfig*) = 0;
/**
* Checked every update to see if the applet is still running. When the applet is done, the core
@ -39,9 +35,14 @@ public:
return running;
}
private:
// framebuffer;
std::atomic_bool running = false;
/**
* Called by the core to receive the result data of this applet.
* Frontend implementation **should** block until the data is ready.
*/
virtual const AppletData* ReceiveData() = 0;
protected:
std::atomic<bool> running = false;
};
/**

28
src/core/frontend/applet/swkbd.cpp → src/core/frontend/applets/swkbd.cpp
View File

@ -2,13 +2,16 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "core/frontend/applet/swkbd.h"
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/frontend/applets/swkbd.h"
namespace Frontend {
ValidationError SoftwareKeyboard::ValidateFilters(const std::string& input) {
if (config.filters.prevent_digit) {
if (std::any_of(input.begin(), input.end(), std::isdigit)) {
if (std::any_of(input.begin(), input.end(),
[](unsigned char c) { return std::isdigit(c); })) {
return ValidationError::DigitNotAllowed;
}
}
@ -22,7 +25,7 @@ ValidationError SoftwareKeyboard::ValidateFilters(const std::string& input) {
return ValidationError::PercentNotAllowed;
}
}
if (config.filter.prevent_backslash) {
if (config.filters.prevent_backslash) {
if (input.find('\\') != std::string::npos) {
return ValidationError::BackslashNotAllowed;
}
@ -35,7 +38,7 @@ ValidationError SoftwareKeyboard::ValidateFilters(const std::string& input) {
// TODO: check the callback
LOG_INFO(Frontend, "App requested a swkbd callback, but its not implemented.");
}
return valid;
return ValidationError::None;
}
ValidationError SoftwareKeyboard::ValidateInput(const std::string& input) {
@ -49,9 +52,12 @@ ValidationError SoftwareKeyboard::ValidateInput(const std::string& input) {
return ValidationError::MaxLengthExceeded;
}
auto is_blank = [&] { return std::all_of(input.begin(), input.end(), std::isspace); };
auto is_blank = [&] {
return std::all_of(input.begin(), input.end(),
[](unsigned char c) { return std::isspace(c); });
};
auto is_empty = [&] { return input.empty(); };
switch (config.valid_input) {
switch (config.accept_mode) {
case AcceptedInput::FixedLength:
if (input.size() != config.max_text_length) {
return ValidationError::FixedLengthRequired;
@ -80,12 +86,12 @@ ValidationError SoftwareKeyboard::ValidateInput(const std::string& input) {
default:
// TODO(jroweboy): What does hardware do in this case?
NGLOG_CRITICAL(Frontend, "Application requested unknown validation method. Method: {}",
static_cast<u32>(config.valid_input));
static_cast<u32>(config.accept_mode));
UNREACHABLE();
}
return ValidationError::None;
} // namespace Frontend
}
ValidationError SoftwareKeyboard::ValidateButton(u8 button) {
switch (config.button_config) {
@ -112,12 +118,12 @@ ValidationError SoftwareKeyboard::ValidateButton(u8 button) {
return ValidationError::None;
}
ValidationError Finalize(cosnt std::string& text, u8 button) {
ValidationError SoftwareKeyboard::Finalize(const std::string& text, u8 button) {
ValidationError error;
if ((error = ValidateInput(text)) != ValidationError::NONE) {
if ((error = ValidateInput(text)) != ValidationError::None) {
return error;
}
if ((error = ValidateButton(button)) != ValidationError::NONE) {
if ((error = ValidateButton(button)) != ValidationError::None) {
return error;
}
data = {text, button};

41
src/core/frontend/applet/swkbd.h → src/core/frontend/applets/swkbd.h
View File

@ -4,8 +4,12 @@
#pragma once
#include <codecvt>
#include <locale>
#include <unordered_map>
#include "core/frontend/applet/interface.h"
#include <utility>
#include <vector>
#include "core/frontend/applets/interface.h"
namespace Frontend {
@ -38,8 +42,8 @@ static const std::unordered_map<ButtonConfig, std::vector<std::string>> DEFAULT_
};
/// Configuration thats relevent to frontend implementation of applets. Anything missing that we
/// later learn is needed can be added here and filled in by the backed HLE applet
struct KeyboardConfig {
/// later learn is needed can be added here and filled in by the backend HLE applet
struct KeyboardConfig : public AppletConfig {
ButtonConfig button_config;
AcceptedInput accept_mode; /// What kinds of input are accepted (blank/empty/fixed width)
bool multiline_mode; /// True if the keyboard accepts multiple lines of input
@ -49,19 +53,23 @@ struct KeyboardConfig {
bool has_custom_button_text; /// If true, use the button_text instead
std::vector<std::string> button_text; /// Contains the button text that the caller provides
struct Filters {
bool prevent_digit; /// Disallow the use of more than a certain number of digits (TODO how
/// many is a certain number)
bool prevent_at; /// Disallow the use of the @ sign.
bool prevent_percent; /// Disallow the use of the % sign.
bool prevent_digit; /// Disallow the use of more than a certain number of digits
/// TODO: how many is a certain number
bool prevent_at; /// Disallow the use of the @ sign.
bool prevent_percent; /// Disallow the use of the % sign.
bool prevent_backslash; /// Disallow the use of the \ sign.
bool prevent_profanity; /// Disallow profanity using Nintendo's profanity filter.
bool enable_callback; /// Use a callback in order to check the input.
} filters;
};
struct KeyboardData {
class KeyboardData : public AppletData {
public:
std::string text;
u8 button;
u8 button{};
KeyboardData(std::string text, u8 button) : text(std::move(text)), button(button) {}
KeyboardData() = default;
};
enum class ValidationError {
@ -77,13 +85,20 @@ enum class ValidationError {
CallbackFailed,
// Allowed Input Type
FixedLengthRequired,
MaxLengthExceeded,
BlankInputNotAllowed,
EmptyInputNotAllowed,
};
class SoftwareKeyboard : public AppletInterface {
public:
explict SoftwareKeyboard(KeyboardConfig config) : AppletInterface(), config(config) {}
explicit SoftwareKeyboard() : AppletInterface() {}
const AppletData* ReceiveData() override {
return &data;
}
void Setup(const AppletConfig* config) override {
this->config = KeyboardConfig(*static_cast<const KeyboardConfig*>(config));
}
protected:
/**
@ -109,13 +124,9 @@ protected:
* Runs all validation phases. If successful, stores the data so that the HLE applet in core can
* send this to the calling application
*/
ValidationError Finialize(const std::string&, u8 button);
ValidationError Finalize(const std::string& text, u8 button);
private:
KeyboardData ReceiveData() override {
return data;
}
KeyboardConfig config;
KeyboardData data;
};

84
src/core/hle/applets/swkbd.cpp
View File

@ -69,22 +69,51 @@ ResultCode SoftwareKeyboard::StartImpl(Service::APT::AppletStartupParameter cons
DrawScreenKeyboard();
using namespace Frontend;
frontend_applet = GetRegisteredApplet(AppletType::SoftwareKeyboard);
if (frontend_applet) {
KeyboardConfig frontend_config = ToFrontendConfig(config);
frontend_applet->Setup(&frontend_config);
}
is_running = true;
return RESULT_SUCCESS;
}
void SoftwareKeyboard::Update() {
// TODO(Subv): Handle input using the touch events from the HID module
// TODO(Subv): Remove this hardcoded text
std::u16string text = Common::UTF8ToUTF16("Citra");
using namespace Frontend;
KeyboardData data(*static_cast<const KeyboardData*>(frontend_applet->ReceiveData()));
std::u16string text = Common::UTF8ToUTF16(data.text);
memcpy(text_memory->GetPointer(), text.c_str(), text.length() * sizeof(char16_t));
switch (config.num_buttons_m1) {
case SoftwareKeyboardButtonConfig::SINGLE_BUTTON:
config.return_code = SoftwareKeyboardResult::D0_CLICK;
break;
case SoftwareKeyboardButtonConfig::DUAL_BUTTON:
if (data.button == 0)
config.return_code = SoftwareKeyboardResult::D1_CLICK0;
else
config.return_code = SoftwareKeyboardResult::D1_CLICK1;
break;
case SoftwareKeyboardButtonConfig::TRIPLE_BUTTON:
if (data.button == 0)
config.return_code = SoftwareKeyboardResult::D2_CLICK0;
else if (data.button == 1)
config.return_code = SoftwareKeyboardResult::D2_CLICK1;
else
config.return_code = SoftwareKeyboardResult::D2_CLICK2;
break;
case SoftwareKeyboardButtonConfig::NO_BUTTON:
// TODO: find out what is actually returned
config.return_code = SoftwareKeyboardResult::NONE;
break;
default:
NGLOG_CRITICAL(Applet_SWKBD, "Unknown button config {}",
static_cast<int>(config.num_buttons_m1));
UNREACHABLE();
}
// TODO(Subv): Ask for input and write it to the shared memory
// TODO(Subv): Find out what are the possible values for the return code,
// some games seem to check for a hardcoded 2
config.return_code = 2;
config.text_length = 6;
config.text_length = static_cast<u16>(text.size() + 1);
config.text_offset = 0;
// TODO(Subv): We're finalizing the applet immediately after it's started,
@ -114,5 +143,42 @@ void SoftwareKeyboard::Finalize() {
is_running = false;
}
Frontend::KeyboardConfig SoftwareKeyboard::ToFrontendConfig(SoftwareKeyboardConfig config) {
using namespace Frontend;
KeyboardConfig frontend_config;
frontend_config.button_config = static_cast<ButtonConfig>(config.num_buttons_m1);
frontend_config.accept_mode = static_cast<AcceptedInput>(config.valid_input);
frontend_config.multiline_mode = config.multiline;
frontend_config.max_text_length = config.max_text_length;
frontend_config.max_digits = config.max_digits;
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
frontend_config.hint_text =
convert.to_bytes(reinterpret_cast<const char16_t*>(config.hint_text.data()));
frontend_config.has_custom_button_text =
std::all_of(config.button_text.begin(), config.button_text.end(),
[](std::array<u16, HLE::Applets::MAX_BUTTON_TEXT_LEN + 1> x) {
return std::all_of(x.begin(), x.end(), [](u16 x) { return x == 0; });
});
if (frontend_config.has_custom_button_text) {
for (const auto& text : config.button_text) {
frontend_config.button_text.push_back(
convert.to_bytes(reinterpret_cast<const char16_t*>(text.data())));
}
}
frontend_config.filters.prevent_digit =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::DIGITS);
frontend_config.filters.prevent_at =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::AT);
frontend_config.filters.prevent_percent =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::PERCENT);
frontend_config.filters.prevent_backslash =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::BACKSLASH);
frontend_config.filters.prevent_profanity =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::PROFANITY);
frontend_config.filters.enable_callback =
static_cast<bool>(config.filter_flags & SoftwareKeyboardFilter::CALLBACK);
return frontend_config;
}
} // namespace Applets
} // namespace HLE

6
src/core/hle/applets/swkbd.h
View File

@ -6,7 +6,7 @@
#include "common/common_funcs.h"
#include "common/common_types.h"
#include "core/frontend/applet/swkbd.h"
#include "core/frontend/applets/swkbd.h"
#include "core/hle/applets/applet.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/shared_memory.h"
@ -197,6 +197,8 @@ public:
void Finalize();
private:
Frontend::KeyboardConfig ToFrontendConfig(SoftwareKeyboardConfig config);
/// This SharedMemory will be created when we receive the LibAppJustStarted message.
/// It holds the framebuffer info retrieved by the application with
/// GSPGPU::ImportDisplayCaptureInfo
@ -207,6 +209,8 @@ private:
/// Configuration of this instance of the SoftwareKeyboard, as received from the application
SoftwareKeyboardConfig config;
std::shared_ptr<Frontend::AppletInterface> frontend_applet;
};
} // namespace Applets
} // namespace HLE