VERY experimental Nintendo Switch 2 emulator
C++
android: Minimal JNI for yuzu.
bunnei573b88b179fc
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txtindex 5e3a74c0f6..55b113297c 100644--- a/src/CMakeLists.txt+++ b/src/CMakeLists.txt@@ -195,3 +195,8 @@ endif()if (ENABLE_WEB_SERVICE)add_subdirectory(web_service)endif()++if (ANDROID)+ add_subdirectory(android/app/src/main/jni)+ target_include_directories(yuzu-android PRIVATE android/app/src/main)+endif()diff --git a/src/android/app/src/main/jni/CMakeLists.txt b/src/android/app/src/main/jni/CMakeLists.txtnew file mode 100644index 0000000000..373c0e8bd0--- /dev/null+++ b/src/android/app/src/main/jni/CMakeLists.txt@@ -0,0 +1,15 @@+add_library(yuzu-android SHARED+ emu_window/emu_window.cpp+ emu_window/emu_window.h+ id_cache.cpp+ id_cache.h+ native.cpp+ native.h+)++set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})++target_link_libraries(yuzu-android PRIVATE audio_core common core input_common)+target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad inih jnigraphics log)++set(CPACK_PACKAGE_EXECUTABLES ${CPACK_PACKAGE_EXECUTABLES} yuzu-android)diff --git a/src/android/app/src/main/jni/emu_window/emu_window.cpp b/src/android/app/src/main/jni/emu_window/emu_window.cppnew file mode 100644index 0000000000..9062c0ae39--- /dev/null+++ b/src/android/app/src/main/jni/emu_window/emu_window.cpp@@ -0,0 +1,58 @@+#include <android/native_window_jni.h>++#include "common/logging/log.h"+#include "input_common/drivers/touch_screen.h"+#include "input_common/drivers/virtual_gamepad.h"+#include "input_common/main.h"+#include "jni/emu_window/emu_window.h"++void EmuWindow_Android::OnSurfaceChanged(ANativeWindow* surface) {+ render_window = surface;+}++bool EmuWindow_Android::OnTouchEvent(float x, float y, bool pressed) {+ if (pressed) {+ input_subsystem->GetTouchScreen()->TouchPressed(NormalizeX(x), NormalizeY(y), 0);+ return true;+ }++ input_subsystem->GetTouchScreen()->ReleaseAllTouch();+ return true;+}++void EmuWindow_Android::OnTouchMoved(float x, float y) {+ input_subsystem->GetTouchScreen()->TouchMoved(NormalizeX(x), NormalizeY(y), 0);+}++void EmuWindow_Android::OnGamepadEvent(int button_id, bool pressed) {+ input_subsystem->GetVirtualGamepad()->SetButtonState(0, button_id, pressed);+}++void EmuWindow_Android::OnGamepadMoveEvent(float x, float y) {+ input_subsystem->GetVirtualGamepad()->SetStickPosition(+ 0, InputCommon::VirtualGamepad::VirtualStick::Left, x, y);+}++EmuWindow_Android::EmuWindow_Android(InputCommon::InputSubsystem* input_subsystem_,+ ANativeWindow* surface_)+ : input_subsystem{input_subsystem_} {+ LOG_INFO(Frontend, "initializing");++ if (!surface_) {+ LOG_CRITICAL(Frontend, "surface is nullptr");+ return;+ }++ window_width = ANativeWindow_getWidth(surface_);+ window_height = ANativeWindow_getHeight(surface_);++ host_window = surface_;+ window_info.type = Core::Frontend::WindowSystemType::Android;+ window_info.render_surface = reinterpret_cast<void*>(host_window);++ input_subsystem->Initialize();+}++EmuWindow_Android::~EmuWindow_Android() {+ input_subsystem->Shutdown();+}diff --git a/src/android/app/src/main/jni/emu_window/emu_window.h b/src/android/app/src/main/jni/emu_window/emu_window.hnew file mode 100644index 0000000000..4af51c5176--- /dev/null+++ b/src/android/app/src/main/jni/emu_window/emu_window.h@@ -0,0 +1,51 @@+#pragma once++#include "core/frontend/emu_window.h"+#include "input_common/main.h"++struct ANativeWindow;++class SharedContext_Android : public Core::Frontend::GraphicsContext {+public:+ SharedContext_Android() = default;+ ~SharedContext_Android() = default;+ void MakeCurrent() override {}+ void DoneCurrent() override {}+};++class EmuWindow_Android : public Core::Frontend::EmuWindow {+public:+ EmuWindow_Android(InputCommon::InputSubsystem* input_subsystem_, ANativeWindow* surface_);+ ~EmuWindow_Android();++ void OnSurfaceChanged(ANativeWindow* surface);+ bool OnTouchEvent(float x, float y, bool pressed);+ void OnTouchMoved(float x, float y);+ void OnGamepadEvent(int button, bool pressed);+ void OnGamepadMoveEvent(float x, float y);+ void OnFrameDisplayed() override {}++ std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override {+ return {std::make_unique<SharedContext_Android>()};+ }+ bool IsShown() const override {+ return true;+ };++private:+ float NormalizeX(float x) const {+ return std::clamp(x / window_width, 0.f, 1.f);+ }++ float NormalizeY(float y) const {+ return std::clamp(y / window_height, 0.f, 1.f);+ }++ InputCommon::InputSubsystem* input_subsystem{};++ ANativeWindow* render_window{};+ ANativeWindow* host_window{};++ float window_width{};+ float window_height{};+};diff --git a/src/android/app/src/main/jni/id_cache.cpp b/src/android/app/src/main/jni/id_cache.cppnew file mode 100644index 0000000000..2955122be8--- /dev/null+++ b/src/android/app/src/main/jni/id_cache.cpp@@ -0,0 +1,36 @@+#include "jni/id_cache.h"++static JavaVM* s_java_vm;+static jclass s_native_library_class;+static jmethodID s_exit_emulation_activity;++namespace IDCache {++JNIEnv* GetEnvForThread() {+ thread_local static struct OwnedEnv {+ OwnedEnv() {+ status = s_java_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);+ if (status == JNI_EDETACHED)+ s_java_vm->AttachCurrentThread(&env, nullptr);+ }++ ~OwnedEnv() {+ if (status == JNI_EDETACHED)+ s_java_vm->DetachCurrentThread();+ }++ int status;+ JNIEnv* env = nullptr;+ } owned;+ return owned.env;+}++jclass GetNativeLibraryClass() {+ return s_native_library_class;+}++jmethodID GetExitEmulationActivity() {+ return s_exit_emulation_activity;+}++} // namespace IDCachediff --git a/src/android/app/src/main/jni/id_cache.h b/src/android/app/src/main/jni/id_cache.hnew file mode 100644index 0000000000..2fe07169d2--- /dev/null+++ b/src/android/app/src/main/jni/id_cache.h@@ -0,0 +1,11 @@+#pragma once++#include <jni.h>++namespace IDCache {++JNIEnv* GetEnvForThread();+jclass GetNativeLibraryClass();+jmethodID GetExitEmulationActivity();++} // namespace IDCachediff --git a/src/android/app/src/main/jni/native.cpp b/src/android/app/src/main/jni/native.cppnew file mode 100644index 0000000000..b343a14532--- /dev/null+++ b/src/android/app/src/main/jni/native.cpp@@ -0,0 +1,342 @@+#include <codecvt>+#include <locale>+#include <string>+#include <string_view>++#include <android/api-level.h>+#include <android/native_window_jni.h>++#include "common/detached_tasks.h"+#include "common/logging/backend.h"+#include "common/logging/log.h"+#include "common/microprofile.h"+#include "common/scm_rev.h"+#include "common/scope_exit.h"+#include "common/settings.h"+#include "core/core.h"+#include "core/cpu_manager.h"+#include "core/file_sys/registered_cache.h"+#include "core/file_sys/vfs_real.h"+#include "core/hle/service/filesystem/filesystem.h"+#include "core/perf_stats.h"+#include "jni/emu_window/emu_window.h"+#include "jni/id_cache.h"+#include "video_core/rasterizer_interface.h"++namespace {++ANativeWindow* s_surf{};+std::unique_ptr<EmuWindow_Android> emu_window;+std::atomic<bool> stop_run{true};+Core::System system_;++std::string UTF16ToUTF8(std::u16string_view input) {+ std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;+ return convert.to_bytes(input.data(), input.data() + input.size());+}++std::string GetJString(JNIEnv* env, jstring jstr) {+ if (!jstr) {+ return {};+ }++ const jchar* jchars = env->GetStringChars(jstr, nullptr);+ const jsize length = env->GetStringLength(jstr);+ const std::u16string_view string_view(reinterpret_cast<const char16_t*>(jchars), length);+ const std::string converted_string = UTF16ToUTF8(string_view);+ env->ReleaseStringChars(jstr, jchars);++ return converted_string;+}++} // Anonymous namespace++static Core::SystemResultStatus RunEmulation(const std::string& filepath) {+ Common::Log::Initialize();+ Common::Log::SetColorConsoleBackendEnabled(true);+ Common::Log::Start();+ Common::DetachedTasks detached_tasks;++ MicroProfileOnThreadCreate("EmuThread");+ SCOPE_EXIT({ MicroProfileShutdown(); });++ LOG_INFO(Frontend, "starting");++ if (filepath.empty()) {+ LOG_CRITICAL(Frontend, "failed to load: filepath empty!");+ return Core::SystemResultStatus::ErrorLoader;+ }++ system_.Initialize();+ system_.ApplySettings();++ InputCommon::InputSubsystem input_subsystem{};++ emu_window = std::make_unique<EmuWindow_Android>(&input_subsystem, s_surf);++ system_.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());+ system_.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());+ system_.GetFileSystemController().CreateFactories(*system_.GetFilesystem());++ const Core::SystemResultStatus load_result{system_.Load(*emu_window, filepath)};++ if (load_result != Core::SystemResultStatus::Success) {+ return load_result;+ }++ system_.GPU().Start();+ system_.GetCpuManager().OnGpuReady();+ system_.RegisterExitCallback([&] { exit(0); });++ void(system_.Run());++ if (system_.DebuggerEnabled()) {+ system_.InitializeDebugger();+ }++ stop_run = false;+ while (!stop_run) {+ std::this_thread::sleep_for(std::chrono::seconds(1));+ }++ system_.DetachDebugger();+ void(system_.Pause());+ system_.ShutdownMainProcess();++ detached_tasks.WaitForAllTasks();++ return Core::SystemResultStatus::Success;+}++extern "C" {++void Java_org_citra_citra_1emu_NativeLibrary_SurfaceChanged(JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jobject surf) {+ s_surf = ANativeWindow_fromSurface(env, surf);++ if (emu_window) {+ emu_window->OnSurfaceChanged(s_surf);+ }++ LOG_INFO(Frontend, "surface changed");+}++void Java_org_citra_citra_1emu_NativeLibrary_SurfaceDestroyed(JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ ANativeWindow_release(s_surf);+ s_surf = nullptr;+ if (emu_window) {+ emu_window->OnSurfaceChanged(s_surf);+ }+}++void Java_org_citra_citra_1emu_NativeLibrary_DoFrame(JNIEnv* env, [[maybe_unused]] jclass clazz) {}++void Java_org_citra_citra_1emu_NativeLibrary_NotifyOrientationChange(JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jint layout_option,+ jint rotation) {}++void Java_org_citra_citra_1emu_NativeLibrary_SetUserDirectory(+ [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_directory) {}++void Java_org_citra_citra_1emu_NativeLibrary_UnPauseEmulation([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {}++void Java_org_citra_citra_1emu_NativeLibrary_PauseEmulation([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {}++void Java_org_citra_citra_1emu_NativeLibrary_StopEmulation([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {}++jboolean Java_org_citra_citra_1emu_NativeLibrary_IsRunning([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ return static_cast<jboolean>(!stop_run);+}++jboolean Java_org_citra_citra_1emu_NativeLibrary_onGamePadEvent([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_device,+ jint j_button, jint action) {+ emu_window->OnGamepadEvent(j_button, action != 0);+ return static_cast<jboolean>(true);+}++jboolean Java_org_citra_citra_1emu_NativeLibrary_onGamePadMoveEvent([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_device, jint axis,+ jfloat x, jfloat y) {+ // Clamp joystick movement to supported minimum and maximum.+ x = std::clamp(x, -1.f, 1.f);+ y = std::clamp(-y, -1.f, 1.f);++ // Clamp the input to a circle.+ float r = x * x + y * y;+ if (r > 1.0f) {+ r = std::sqrt(r);+ x /= r;+ y /= r;+ }+ emu_window->OnGamepadMoveEvent(x, y);+ return static_cast<jboolean>(false);+}++jboolean Java_org_citra_citra_1emu_NativeLibrary_onGamePadAxisEvent([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_device, jint axis_id,+ jfloat axis_val) {+ return {};+}++jboolean Java_org_citra_citra_1emu_NativeLibrary_onTouchEvent([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jfloat x, jfloat y,+ jboolean pressed) {+ return static_cast<jboolean>(emu_window->OnTouchEvent(x, y, pressed));+}++void Java_org_citra_citra_1emu_NativeLibrary_onTouchMoved([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz, jfloat x,+ jfloat y) {+ emu_window->OnTouchMoved(x, y);+}++jintArray Java_org_citra_citra_1emu_NativeLibrary_GetIcon([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_file) {+ return {};+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetTitle([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_filename) {+ return env->NewStringUTF("");+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetDescription([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_filename) {+ return j_filename;+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetGameId([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_filename) {+ return j_filename;+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetRegions([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_filename) {+ return env->NewStringUTF("");+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetCompany([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ [[maybe_unused]] jstring j_filename) {+ return env->NewStringUTF("");+}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetGitRevision([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ return {};+}++void Java_org_citra_citra_1emu_NativeLibrary_CreateConfigFile+ [[maybe_unused]] (JNIEnv* env, [[maybe_unused]] jclass clazz) {}++jint Java_org_citra_citra_1emu_NativeLibrary_DefaultCPUCore([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ return {};+}++void Java_org_citra_citra_1emu_NativeLibrary_Run__Ljava_lang_String_2Ljava_lang_String_2Z(+ [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, [[maybe_unused]] jstring j_file,+ [[maybe_unused]] jstring j_savestate, [[maybe_unused]] jboolean j_delete_savestate) {}++void Java_org_citra_citra_1emu_NativeLibrary_ReloadSettings([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {}++jstring Java_org_citra_citra_1emu_NativeLibrary_GetUserSetting([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_game_id, jstring j_section,+ jstring j_key) {+ std::string_view game_id = env->GetStringUTFChars(j_game_id, 0);+ std::string_view section = env->GetStringUTFChars(j_section, 0);+ std::string_view key = env->GetStringUTFChars(j_key, 0);++ env->ReleaseStringUTFChars(j_game_id, game_id.data());+ env->ReleaseStringUTFChars(j_section, section.data());+ env->ReleaseStringUTFChars(j_key, key.data());++ return env->NewStringUTF("");+}++void Java_org_citra_citra_1emu_NativeLibrary_SetUserSetting([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_game_id, jstring j_section,+ jstring j_key, jstring j_value) {+ std::string_view game_id = env->GetStringUTFChars(j_game_id, 0);+ std::string_view section = env->GetStringUTFChars(j_section, 0);+ std::string_view key = env->GetStringUTFChars(j_key, 0);+ std::string_view value = env->GetStringUTFChars(j_value, 0);++ env->ReleaseStringUTFChars(j_game_id, game_id.data());+ env->ReleaseStringUTFChars(j_section, section.data());+ env->ReleaseStringUTFChars(j_key, key.data());+ env->ReleaseStringUTFChars(j_value, value.data());+}++void Java_org_citra_citra_1emu_NativeLibrary_InitGameIni([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_game_id) {+ std::string_view game_id = env->GetStringUTFChars(j_game_id, 0);++ env->ReleaseStringUTFChars(j_game_id, game_id.data());+}++jdoubleArray Java_org_citra_citra_1emu_NativeLibrary_GetPerfStats([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ jdoubleArray j_stats = env->NewDoubleArray(4);++ if (!stop_run && system_.IsPoweredOn()) {+ const auto results = system_.GetAndResetPerfStats();++ // Converting the structure into an array makes it easier to pass it to the frontend+ double stats[4] = {results.system_fps, results.average_game_fps, results.frametime,+ results.emulation_speed};++ env->SetDoubleArrayRegion(j_stats, 0, 4, stats);+ }++ return j_stats;+}++void Java_org_citra_citra_1emu_utils_DirectoryInitialization_SetSysDirectory(+ [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jstring j_path) {}++void Java_org_citra_citra_1emu_NativeLibrary_Run__Ljava_lang_String_2([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz,+ jstring j_path) {+ const std::string path = GetJString(env, j_path);++ if (!stop_run) {+ stop_run = true;+ }++ const Core::SystemResultStatus result{RunEmulation(path)};+ if (result != Core::SystemResultStatus::Success) {+ env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),+ IDCache::GetExitEmulationActivity(), static_cast<int>(result));+ }+}++void Java_org_citra_citra_1emu_NativeLibrary_LogDeviceInfo([[maybe_unused]] JNIEnv* env,+ [[maybe_unused]] jclass clazz) {+ LOG_INFO(Frontend, "yuzu Version: {}-{}", Common::g_scm_branch, Common::g_scm_desc);+ LOG_INFO(Frontend, "Host OS: Android API level {}", android_get_device_api_level());+}++} // extern "C"diff --git a/src/android/app/src/main/jni/native.h b/src/android/app/src/main/jni/native.hnew file mode 100644index 0000000000..16c90e215d--- /dev/null+++ b/src/android/app/src/main/jni/native.h@@ -0,0 +1,127 @@+#pragma once++#include <jni.h>++// Function calls from the Java side+#ifdef __cplusplus+extern "C" {+#endif++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_UnPauseEmulation(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_PauseEmulation(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_StopEmulation(JNIEnv* env,+ jclass clazz);++JNIEXPORT jboolean JNICALL Java_org_citra_citra_1emu_NativeLibrary_IsRunning(JNIEnv* env,+ jclass clazz);++JNIEXPORT jboolean JNICALL Java_org_citra_citra_1emu_NativeLibrary_onGamePadEvent(+ JNIEnv* env, jclass clazz, jstring j_device, jint j_button, jint action);++JNIEXPORT jboolean JNICALL Java_org_citra_citra_1emu_NativeLibrary_onGamePadMoveEvent(+ JNIEnv* env, jclass clazz, jstring j_device, jint axis, jfloat x, jfloat y);++JNIEXPORT jboolean JNICALL Java_org_citra_citra_1emu_NativeLibrary_onGamePadAxisEvent(+ JNIEnv* env, jclass clazz, jstring j_device, jint axis_id, jfloat axis_val);++JNIEXPORT jboolean JNICALL Java_org_citra_citra_1emu_NativeLibrary_onTouchEvent(JNIEnv* env,+ jclass clazz,+ jfloat x, jfloat y,+ jboolean pressed);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_onTouchMoved(JNIEnv* env,+ jclass clazz, jfloat x,+ jfloat y);++JNIEXPORT jintArray JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetIcon(JNIEnv* env,+ jclass clazz,+ jstring j_file);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetTitle(JNIEnv* env,+ jclass clazz,+ jstring j_filename);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetDescription(+ JNIEnv* env, jclass clazz, jstring j_filename);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetGameId(JNIEnv* env,+ jclass clazz,+ jstring j_filename);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetRegions(JNIEnv* env,+ jclass clazz,+ jstring j_filename);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetCompany(JNIEnv* env,+ jclass clazz,+ jstring j_filename);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetGitRevision(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SetUserDirectory(+ JNIEnv* env, jclass clazz, jstring j_directory);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_utils_DirectoryInitialization_SetSysDirectory(+ JNIEnv* env, jclass clazz, jstring path_);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SetSysDirectory(JNIEnv* env,+ jclass clazz,+ jstring path);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_CreateConfigFile(JNIEnv* env,+ jclass clazz);++JNIEXPORT jint JNICALL Java_org_citra_citra_1emu_NativeLibrary_DefaultCPUCore(JNIEnv* env,+ jclass clazz);+JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SetProfiling(JNIEnv* env,+ jclass clazz,+ jboolean enable);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_WriteProfileResults(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_NotifyOrientationChange(+ JNIEnv* env, jclass clazz, jint layout_option, jint rotation);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_Run__Ljava_lang_String_2(+ JNIEnv* env, jclass clazz, jstring j_path);++JNIEXPORT void JNICALL+Java_org_citra_citra_1emu_NativeLibrary_Run__Ljava_lang_String_2Ljava_lang_String_2Z(+ JNIEnv* env, jclass clazz, jstring j_file, jstring j_savestate, jboolean j_delete_savestate);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SurfaceChanged(JNIEnv* env,+ jclass clazz,+ jobject surf);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SurfaceDestroyed(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_InitGameIni(JNIEnv* env,+ jclass clazz,+ jstring j_game_id);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_ReloadSettings(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_SetUserSetting(+ JNIEnv* env, jclass clazz, jstring j_game_id, jstring j_section, jstring j_key,+ jstring j_value);++JNIEXPORT jstring JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetUserSetting(+ JNIEnv* env, jclass clazz, jstring game_id, jstring section, jstring key);++JNIEXPORT jdoubleArray JNICALL Java_org_citra_citra_1emu_NativeLibrary_GetPerfStats(JNIEnv* env,+ jclass clazz);++JNIEXPORT void JNICALL Java_org_citra_citra_1emu_NativeLibrary_LogDeviceInfo(JNIEnv* env,+ jclass clazz);++#ifdef __cplusplus+}+#endif