Merge pull request #11385 from JosJuice/android-input-overhaul

Android input overhaul

Source/Android/jni/AndroidCommon/IDCache.cpp

@@ -13,7 +13,6 @@ static jclass s_string_class;
 
 static jclass s_native_library_class;
 static jmethodID s_display_alert_msg;
-static jmethodID s_do_rumble;
 static jmethodID s_update_touch_pointer;
 static jmethodID s_on_title_changed;
 static jmethodID s_finish_emulation_activity;
@@ -84,6 +83,34 @@ static jfieldID s_riivolution_patches_pointer;
 static jclass s_wii_update_cb_class;
 static jmethodID s_wii_update_cb_run;
 
+static jclass s_control_class;
+static jfieldID s_control_pointer;
+static jmethodID s_control_constructor;
+
+static jclass s_numeric_setting_class;
+static jfieldID s_numeric_setting_pointer;
+static jmethodID s_numeric_setting_constructor;
+
+static jclass s_control_group_class;
+static jfieldID s_control_group_pointer;
+static jmethodID s_control_group_constructor;
+
+static jclass s_control_reference_class;
+static jfieldID s_control_reference_pointer;
+static jmethodID s_control_reference_constructor;
+
+static jclass s_emulated_controller_class;
+static jfieldID s_emulated_controller_pointer;
+static jmethodID s_emulated_controller_constructor;
+
+static jclass s_core_device_class;
+static jfieldID s_core_device_pointer;
+static jmethodID s_core_device_constructor;
+
+static jclass s_core_device_control_class;
+static jfieldID s_core_device_control_pointer;
+static jmethodID s_core_device_control_constructor;
+
 namespace IDCache
 {
 JNIEnv* GetEnvForThread()
@@ -124,11 +151,6 @@ jmethodID GetDisplayAlertMsg()
   return s_display_alert_msg;
 }
 
-jmethodID GetDoRumble()
-{
-  return s_do_rumble;
-}
-
 jmethodID GetUpdateTouchPointer()
 {
   return s_update_touch_pointer;
@@ -389,6 +411,111 @@ jmethodID GetWiiUpdateCallbackFunction()
   return s_wii_update_cb_run;
 }
 
+jclass GetControlClass()
+{
+  return s_control_class;
+}
+
+jfieldID GetControlPointer()
+{
+  return s_control_pointer;
+}
+
+jmethodID GetControlConstructor()
+{
+  return s_control_constructor;
+}
+
+jclass GetControlGroupClass()
+{
+  return s_control_group_class;
+}
+
+jfieldID GetControlGroupPointer()
+{
+  return s_control_group_pointer;
+}
+
+jmethodID GetControlGroupConstructor()
+{
+  return s_control_group_constructor;
+}
+
+jclass GetControlReferenceClass()
+{
+  return s_control_reference_class;
+}
+
+jfieldID GetControlReferencePointer()
+{
+  return s_control_reference_pointer;
+}
+
+jmethodID GetControlReferenceConstructor()
+{
+  return s_control_reference_constructor;
+}
+
+jclass GetEmulatedControllerClass()
+{
+  return s_emulated_controller_class;
+}
+
+jfieldID GetEmulatedControllerPointer()
+{
+  return s_emulated_controller_pointer;
+}
+
+jmethodID GetEmulatedControllerConstructor()
+{
+  return s_emulated_controller_constructor;
+}
+
+jclass GetNumericSettingClass()
+{
+  return s_numeric_setting_class;
+}
+
+jfieldID GetNumericSettingPointer()
+{
+  return s_numeric_setting_pointer;
+}
+
+jmethodID GetNumericSettingConstructor()
+{
+  return s_numeric_setting_constructor;
+}
+
+jclass GetCoreDeviceClass()
+{
+  return s_core_device_class;
+}
+
+jfieldID GetCoreDevicePointer()
+{
+  return s_core_device_pointer;
+}
+
+jmethodID GetCoreDeviceConstructor()
+{
+  return s_core_device_constructor;
+}
+
+jclass GetCoreDeviceControlClass()
+{
+  return s_core_device_control_class;
+}
+
+jfieldID GetCoreDeviceControlPointer()
+{
+  return s_core_device_control_pointer;
+}
+
+jmethodID GetCoreDeviceControlConstructor()
+{
+  return s_core_device_control_constructor;
+}
+
 }  // namespace IDCache
 
 extern "C" {
@@ -408,7 +535,6 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
   s_native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
   s_display_alert_msg = env->GetStaticMethodID(s_native_library_class, "displayAlertMsg",
                                                "(Ljava/lang/String;Ljava/lang/String;ZZZ)Z");
-  s_do_rumble = env->GetStaticMethodID(s_native_library_class, "rumble", "(ID)V");
   s_update_touch_pointer =
       env->GetStaticMethodID(s_native_library_class, "updateTouchPointer", "()V");
   s_on_title_changed = env->GetStaticMethodID(s_native_library_class, "onTitleChanged", "()V");
@@ -548,6 +674,59 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
   s_wii_update_cb_run = env->GetMethodID(s_wii_update_cb_class, "run", "(IIJ)Z");
   env->DeleteLocalRef(wii_update_cb_class);
 
+  const jclass control_class =
+      env->FindClass("org/dolphinemu/dolphinemu/features/input/model/controlleremu/Control");
+  s_control_class = reinterpret_cast<jclass>(env->NewGlobalRef(control_class));
+  s_control_pointer = env->GetFieldID(control_class, "mPointer", "J");
+  s_control_constructor = env->GetMethodID(control_class, "<init>", "(J)V");
+  env->DeleteLocalRef(control_class);
+
+  const jclass control_group_class =
+      env->FindClass("org/dolphinemu/dolphinemu/features/input/model/controlleremu/ControlGroup");
+  s_control_group_class = reinterpret_cast<jclass>(env->NewGlobalRef(control_group_class));
+  s_control_group_pointer = env->GetFieldID(control_group_class, "mPointer", "J");
+  s_control_group_constructor = env->GetMethodID(control_group_class, "<init>", "(J)V");
+  env->DeleteLocalRef(control_group_class);
+
+  const jclass control_reference_class = env->FindClass(
+      "org/dolphinemu/dolphinemu/features/input/model/controlleremu/ControlReference");
+  s_control_reference_class = reinterpret_cast<jclass>(env->NewGlobalRef(control_reference_class));
+  s_control_reference_pointer = env->GetFieldID(control_reference_class, "mPointer", "J");
+  s_control_reference_constructor = env->GetMethodID(control_reference_class, "<init>", "(J)V");
+  env->DeleteLocalRef(control_reference_class);
+
+  const jclass emulated_controller_class = env->FindClass(
+      "org/dolphinemu/dolphinemu/features/input/model/controlleremu/EmulatedController");
+  s_emulated_controller_class =
+      reinterpret_cast<jclass>(env->NewGlobalRef(emulated_controller_class));
+  s_emulated_controller_pointer = env->GetFieldID(emulated_controller_class, "mPointer", "J");
+  s_emulated_controller_constructor = env->GetMethodID(emulated_controller_class, "<init>", "(J)V");
+  env->DeleteLocalRef(emulated_controller_class);
+
+  const jclass numeric_setting_class =
+      env->FindClass("org/dolphinemu/dolphinemu/features/input/model/controlleremu/NumericSetting");
+  s_numeric_setting_class = reinterpret_cast<jclass>(env->NewGlobalRef(numeric_setting_class));
+  s_numeric_setting_pointer = env->GetFieldID(numeric_setting_class, "mPointer", "J");
+  s_numeric_setting_constructor = env->GetMethodID(numeric_setting_class, "<init>", "(J)V");
+  env->DeleteLocalRef(numeric_setting_class);
+
+  const jclass core_device_class =
+      env->FindClass("org/dolphinemu/dolphinemu/features/input/model/CoreDevice");
+  s_core_device_class = reinterpret_cast<jclass>(env->NewGlobalRef(core_device_class));
+  s_core_device_pointer = env->GetFieldID(core_device_class, "mPointer", "J");
+  s_core_device_constructor = env->GetMethodID(core_device_class, "<init>", "(J)V");
+  env->DeleteLocalRef(core_device_class);
+
+  const jclass core_device_control_class =
+      env->FindClass("org/dolphinemu/dolphinemu/features/input/model/CoreDevice$Control");
+  s_core_device_control_class =
+      reinterpret_cast<jclass>(env->NewGlobalRef(core_device_control_class));
+  s_core_device_control_pointer = env->GetFieldID(core_device_control_class, "mPointer", "J");
+  s_core_device_control_constructor =
+      env->GetMethodID(core_device_control_class, "<init>",
+                       "(Lorg/dolphinemu/dolphinemu/features/input/model/CoreDevice;J)V");
+  env->DeleteLocalRef(core_device_control_class);
+
   return JNI_VERSION;
 }
 
@@ -575,5 +754,12 @@ JNIEXPORT void JNI_OnUnload(JavaVM* vm, void* reserved)
   env->DeleteGlobalRef(s_graphics_mod_class);
   env->DeleteGlobalRef(s_riivolution_patches_class);
   env->DeleteGlobalRef(s_wii_update_cb_class);
+  env->DeleteGlobalRef(s_control_class);
+  env->DeleteGlobalRef(s_control_group_class);
+  env->DeleteGlobalRef(s_control_reference_class);
+  env->DeleteGlobalRef(s_emulated_controller_class);
+  env->DeleteGlobalRef(s_numeric_setting_class);
+  env->DeleteGlobalRef(s_core_device_class);
+  env->DeleteGlobalRef(s_core_device_control_class);
 }
 }

Source/Android/jni/AndroidCommon/IDCache.h

@@ -13,7 +13,6 @@ jclass GetStringClass();
 
 jclass GetNativeLibraryClass();
 jmethodID GetDisplayAlertMsg();
-jmethodID GetDoRumble();
 jmethodID GetUpdateTouchPointer();
 jmethodID GetOnTitleChanged();
 jmethodID GetFinishEmulationActivity();
@@ -83,4 +82,32 @@ jfieldID GetRiivolutionPatchesPointer();
 jclass GetWiiUpdateCallbackClass();
 jmethodID GetWiiUpdateCallbackFunction();
 
+jclass GetControlClass();
+jfieldID GetControlPointer();
+jmethodID GetControlConstructor();
+
+jclass GetControlGroupClass();
+jfieldID GetControlGroupPointer();
+jmethodID GetControlGroupConstructor();
+
+jclass GetControlReferenceClass();
+jfieldID GetControlReferencePointer();
+jmethodID GetControlReferenceConstructor();
+
+jclass GetEmulatedControllerClass();
+jfieldID GetEmulatedControllerPointer();
+jmethodID GetEmulatedControllerConstructor();
+
+jclass GetNumericSettingClass();
+jfieldID GetNumericSettingPointer();
+jmethodID GetNumericSettingConstructor();
+
+jclass GetCoreDeviceClass();
+jfieldID GetCoreDevicePointer();
+jmethodID GetCoreDeviceConstructor();
+
+jclass GetCoreDeviceControlClass();
+jfieldID GetCoreDeviceControlPointer();
+jmethodID GetCoreDeviceControlConstructor();
+
 }  // namespace IDCache

Source/Android/jni/CMakeLists.txt

@@ -10,7 +10,20 @@ add_library(main SHARED
   GameList/GameFile.cpp
   GameList/GameFile.h
   GameList/GameFileCache.cpp
+  Input/Control.cpp
+  Input/Control.h
+  Input/ControlGroup.cpp
+  Input/ControlGroup.h
+  Input/ControlReference.cpp
+  Input/ControlReference.h
+  Input/CoreDevice.cpp
+  Input/CoreDevice.h
+  Input/EmulatedController.cpp
+  Input/EmulatedController.h
   Input/InputOverrider.cpp
+  Input/MappingCommon.cpp
+  Input/NumericSetting.cpp
+  Input/NumericSetting.h
   IniFile.cpp
   MainAndroid.cpp
   RiivolutionPatches.cpp
@@ -23,6 +36,7 @@ PRIVATE
   androidcommon
   common
   core
+  inputcommon
   uicommon
 )
 

Source/Android/jni/Input/Control.cpp

@@ -0,0 +1,51 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "jni/Input/Control.h"
+
+#include <string>
+
+#include <jni.h>
+
+#include "Common/MsgHandler.h"
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+#include "jni/Input/ControlReference.h"
+
+static ControllerEmu::Control* GetPointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ControllerEmu::Control*>(
+      env->GetLongField(obj, IDCache::GetControlPointer()));
+}
+
+jobject ControlToJava(JNIEnv* env, ControllerEmu::Control* control)
+{
+  if (!control)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetControlClass(), IDCache::GetControlConstructor(),
+                        reinterpret_cast<jlong>(control));
+}
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_Control_getUiName(JNIEnv* env,
+                                                                                    jobject obj)
+{
+  ControllerEmu::Control* control = GetPointer(env, obj);
+  std::string ui_name = control->ui_name;
+  if (control->translate == ControllerEmu::Translatability::Translate)
+    ui_name = Common::GetStringT(ui_name.c_str());
+  return ToJString(env, ui_name);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_Control_getControlReference(
+    JNIEnv* env, jobject obj)
+{
+  return ControlReferenceToJava(env, GetPointer(env, obj)->control_ref.get());
+}
+}

Source/Android/jni/Input/Control.h

@@ -0,0 +1,13 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <jni.h>
+
+namespace ControllerEmu
+{
+class Control;
+}
+
+jobject ControlToJava(JNIEnv* env, ControllerEmu::Control* control);

Source/Android/jni/Input/ControlGroup.cpp

@@ -0,0 +1,103 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "jni/Input/ControlGroup.h"
+
+#include <jni.h>
+
+#include "Common/MsgHandler.h"
+#include "InputCommon/ControllerEmu/ControlGroup/Attachments.h"
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+#include "jni/Input/Control.h"
+#include "jni/Input/NumericSetting.h"
+
+static ControllerEmu::ControlGroup* GetPointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ControllerEmu::ControlGroup*>(
+      env->GetLongField(obj, IDCache::GetControlGroupPointer()));
+}
+
+jobject ControlGroupToJava(JNIEnv* env, ControllerEmu::ControlGroup* group)
+{
+  if (!group)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetControlGroupClass(), IDCache::GetControlGroupConstructor(),
+                        reinterpret_cast<jlong>(group));
+}
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getUiName(
+    JNIEnv* env, jobject obj)
+{
+  return ToJString(env, Common::GetStringT(GetPointer(env, obj)->ui_name.c_str()));
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getGroupType(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(GetPointer(env, obj)->type);
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getDefaultEnabledValue(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(GetPointer(env, obj)->default_value);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getEnabled(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jboolean>(GetPointer(env, obj)->enabled);
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_setEnabled(
+    JNIEnv* env, jobject obj, jboolean value)
+{
+  GetPointer(env, obj)->enabled = value;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getControlCount(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(GetPointer(env, obj)->controls.size());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getControl(
+    JNIEnv* env, jobject obj, jint i)
+{
+  return ControlToJava(env, GetPointer(env, obj)->controls[i].get());
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getNumericSettingCount(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(GetPointer(env, obj)->numeric_settings.size());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getNumericSetting(
+    JNIEnv* env, jobject obj, jint i)
+{
+  return NumericSettingToJava(env, GetPointer(env, obj)->numeric_settings[i].get());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlGroup_getAttachmentSetting(
+    JNIEnv* env, jobject obj)
+{
+  auto* group = reinterpret_cast<ControllerEmu::Attachments*>(GetPointer(env, obj));
+  return NumericSettingToJava(env, &group->GetSelectionSetting());
+}
+}

Source/Android/jni/Input/ControlGroup.h

@@ -0,0 +1,13 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <jni.h>
+
+namespace ControllerEmu
+{
+class ControlGroup;
+}
+
+jobject ControlGroupToJava(JNIEnv* env, ControllerEmu::ControlGroup* group);

Source/Android/jni/Input/ControlReference.cpp

@@ -0,0 +1,61 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "jni/Input/ControlReference.h"
+
+#include <string>
+
+#include <jni.h>
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+
+ControlReference* ControlReferenceFromJava(JNIEnv* env, jobject control_reference)
+{
+  return reinterpret_cast<ControlReference*>(
+      env->GetLongField(control_reference, IDCache::GetControlReferencePointer()));
+}
+
+jobject ControlReferenceToJava(JNIEnv* env, ControlReference* control_reference)
+{
+  if (!control_reference)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetControlReferenceClass(),
+                        IDCache::GetControlReferenceConstructor(),
+                        reinterpret_cast<jlong>(control_reference));
+}
+
+extern "C" {
+
+JNIEXPORT jdouble JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlReference_getState(
+    JNIEnv* env, jobject obj)
+{
+  return ControlReferenceFromJava(env, obj)->GetState<double>();
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlReference_getExpression(
+    JNIEnv* env, jobject obj)
+{
+  return ToJString(env, ControlReferenceFromJava(env, obj)->GetExpression());
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlReference_setExpression(
+    JNIEnv* env, jobject obj, jstring expr)
+{
+  const std::optional<std::string> result =
+      ControlReferenceFromJava(env, obj)->SetExpression(GetJString(env, expr));
+  return result ? ToJString(env, *result) : nullptr;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_ControlReference_isInput(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jboolean>(ControlReferenceFromJava(env, obj)->IsInput());
+}
+}

Source/Android/jni/Input/ControlReference.h

@@ -0,0 +1,11 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <jni.h>
+
+class ControlReference;
+
+jobject ControlReferenceToJava(JNIEnv* env, ControlReference* control_reference);
+ControlReference* ControlReferenceFromJava(JNIEnv* env, jobject control_reference);

Source/Android/jni/Input/CoreDevice.cpp

@@ -0,0 +1,84 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "jni/Input/CoreDevice.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jni.h>
+
+#include "InputCommon/ControllerInterface/CoreDevice.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+
+static ciface::Core::Device::Control* GetControlPointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ciface::Core::Device::Control*>(
+      env->GetLongField(obj, IDCache::GetCoreDeviceControlPointer()));
+}
+
+static jobject CoreDeviceControlToJava(JNIEnv* env, jobject device,
+                                       ciface::Core::Device::Control* control)
+{
+  if (!control)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetCoreDeviceControlClass(),
+                        IDCache::GetCoreDeviceControlConstructor(), device,
+                        reinterpret_cast<jlong>(control));
+}
+
+template <typename T>
+static jobjectArray CoreDeviceControlVectorToJava(JNIEnv* env, jobject device,
+                                                  const std::vector<T*>& controls)
+{
+  return VectorToJObjectArray(
+      env, controls, IDCache::GetCoreDeviceControlClass(),
+      [device](JNIEnv* env, T* control) { return CoreDeviceControlToJava(env, device, control); });
+}
+
+static std::shared_ptr<ciface::Core::Device>* GetDevicePointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<std::shared_ptr<ciface::Core::Device>*>(
+      env->GetLongField(obj, IDCache::GetCoreDevicePointer()));
+}
+
+jobject CoreDeviceToJava(JNIEnv* env, std::shared_ptr<ciface::Core::Device> device)
+{
+  if (!device)
+    return nullptr;
+
+  return env->NewObject(
+      IDCache::GetCoreDeviceClass(), IDCache::GetCoreDeviceConstructor(),
+      reinterpret_cast<jlong>(new std::shared_ptr<ciface::Core::Device>(std::move(device))));
+}
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_CoreDevice_00024Control_getName(JNIEnv* env,
+                                                                                    jobject obj)
+{
+  return ToJString(env, GetControlPointer(env, obj)->GetName());
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_CoreDevice_finalize(JNIEnv* env, jobject obj)
+{
+  delete GetDevicePointer(env, obj);
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_CoreDevice_getInputs(JNIEnv* env, jobject obj)
+{
+  return CoreDeviceControlVectorToJava(env, obj, (*GetDevicePointer(env, obj))->Inputs());
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_CoreDevice_getOutputs(JNIEnv* env, jobject obj)
+{
+  return CoreDeviceControlVectorToJava(env, obj, (*GetDevicePointer(env, obj))->Outputs());
+}
+}

Source/Android/jni/Input/CoreDevice.h

@@ -0,0 +1,15 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include <jni.h>
+
+namespace ciface::Core
+{
+class Device;
+}
+
+jobject CoreDeviceToJava(JNIEnv* env, std::shared_ptr<ciface::Core::Device> device);

Source/Android/jni/Input/EmulatedController.cpp

@@ -0,0 +1,174 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <jni.h>
+
+#include "Common/FileUtil.h"
+#include "Common/IniFile.h"
+#include "Core/HW/GCPad.h"
+#include "Core/HW/Wiimote.h"
+#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
+#include "InputCommon/ControllerEmu/ControlGroup/Attachments.h"
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+#include "InputCommon/ControllerInterface/ControllerInterface.h"
+#include "InputCommon/InputConfig.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+#include "jni/Input/Control.h"
+#include "jni/Input/ControlGroup.h"
+#include "jni/Input/ControlReference.h"
+#include "jni/Input/NumericSetting.h"
+
+ControllerEmu::EmulatedController* EmulatedControllerFromJava(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ControllerEmu::EmulatedController*>(
+      env->GetLongField(obj, IDCache::GetEmulatedControllerPointer()));
+}
+
+static jobject EmulatedControllerToJava(JNIEnv* env, ControllerEmu::EmulatedController* controller)
+{
+  if (!controller)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetEmulatedControllerClass(),
+                        IDCache::GetEmulatedControllerConstructor(),
+                        reinterpret_cast<jlong>(controller));
+}
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getDefaultDevice(
+    JNIEnv* env, jobject obj)
+{
+  return ToJString(env, EmulatedControllerFromJava(env, obj)->GetDefaultDevice().ToString());
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_setDefaultDevice(
+    JNIEnv* env, jobject obj, jstring j_device)
+{
+  return EmulatedControllerFromJava(env, obj)->SetDefaultDevice(GetJString(env, j_device));
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getGroupCount(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(EmulatedControllerFromJava(env, obj)->groups.size());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getGroup(
+    JNIEnv* env, jobject obj, jint controller_index)
+{
+  return ControlGroupToJava(env,
+                            EmulatedControllerFromJava(env, obj)->groups[controller_index].get());
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_updateSingleControlReference(
+    JNIEnv* env, jobject obj, jobject control_reference)
+{
+  return EmulatedControllerFromJava(env, obj)->UpdateSingleControlReference(
+      g_controller_interface, ControlReferenceFromJava(env, control_reference));
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_loadDefaultSettings(
+    JNIEnv* env, jobject obj)
+{
+  ControllerEmu::EmulatedController* controller = EmulatedControllerFromJava(env, obj);
+
+  controller->LoadDefaults(g_controller_interface);
+  controller->UpdateReferences(g_controller_interface);
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_clearSettings(
+    JNIEnv* env, jobject obj)
+{
+  ControllerEmu::EmulatedController* controller = EmulatedControllerFromJava(env, obj);
+
+  // Loading an empty IniFile section clears everything.
+  IniFile::Section section;
+
+  controller->LoadConfig(&section);
+  controller->UpdateReferences(g_controller_interface);
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_loadProfile(
+    JNIEnv* env, jobject obj, jstring j_path)
+{
+  ControllerEmu::EmulatedController* controller = EmulatedControllerFromJava(env, obj);
+
+  IniFile ini;
+  ini.Load(GetJString(env, j_path));
+
+  controller->LoadConfig(ini.GetOrCreateSection("Profile"));
+  controller->UpdateReferences(g_controller_interface);
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_saveProfile(
+    JNIEnv* env, jobject obj, jstring j_path)
+{
+  const std::string path = GetJString(env, j_path);
+
+  File::CreateFullPath(path);
+
+  IniFile ini;
+
+  EmulatedControllerFromJava(env, obj)->SaveConfig(ini.GetOrCreateSection("Profile"));
+  ini.Save(path);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getGcPad(
+    JNIEnv* env, jclass, jint controller_index)
+{
+  return EmulatedControllerToJava(env, Pad::GetConfig()->GetController(controller_index));
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getWiimote(
+    JNIEnv* env, jclass, jint controller_index)
+{
+  return EmulatedControllerToJava(env, Wiimote::GetConfig()->GetController(controller_index));
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getWiimoteAttachment(
+    JNIEnv* env, jclass, jint controller_index, jint attachment_index)
+{
+  auto* attachments = static_cast<ControllerEmu::Attachments*>(
+      Wiimote::GetWiimoteGroup(controller_index, WiimoteEmu::WiimoteGroup::Attachments));
+  return EmulatedControllerToJava(env, attachments->GetAttachmentList()[attachment_index].get());
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getSelectedWiimoteAttachment(
+    JNIEnv* env, jclass, jint controller_index)
+{
+  auto* attachments = static_cast<ControllerEmu::Attachments*>(
+      Wiimote::GetWiimoteGroup(controller_index, WiimoteEmu::WiimoteGroup::Attachments));
+  return static_cast<jint>(attachments->GetSelectedAttachment());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getSidewaysWiimoteSetting(
+    JNIEnv* env, jclass, jint controller_index)
+{
+  ControllerEmu::ControlGroup* options =
+      Wiimote::GetWiimoteGroup(controller_index, WiimoteEmu::WiimoteGroup::Options);
+
+  for (auto& setting : options->numeric_settings)
+  {
+    if (setting->GetININame() == WiimoteEmu::Wiimote::SIDEWAYS_OPTION)
+      return NumericSettingToJava(env, setting.get());
+  }
+
+  return nullptr;
+}
+}

Source/Android/jni/Input/EmulatedController.h

@@ -0,0 +1,13 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <jni.h>
+
+namespace ControllerEmu
+{
+class ControlReference;
+}
+
+ControllerEmu::EmulatedController* EmulatedControllerFromJava(JNIEnv* env, jobject obj);

Source/Android/jni/Input/MappingCommon.cpp

@@ -0,0 +1,79 @@
+// Copyright 2022 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <chrono>
+#include <string>
+#include <vector>
+
+#include <jni.h>
+
+#include "Core/FreeLookManager.h"
+#include "Core/HW/GBAPad.h"
+#include "Core/HW/GCKeyboard.h"
+#include "Core/HW/GCPad.h"
+#include "Core/HW/Wiimote.h"
+#include "Core/HotkeyManager.h"
+#include "InputCommon/ControllerInterface/ControllerInterface.h"
+#include "InputCommon/ControllerInterface/MappingCommon.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/Input/EmulatedController.h"
+
+namespace
+{
+constexpr auto INPUT_DETECT_INITIAL_TIME = std::chrono::seconds(3);
+constexpr auto INPUT_DETECT_CONFIRMATION_TIME = std::chrono::milliseconds(0);
+constexpr auto INPUT_DETECT_MAXIMUM_TIME = std::chrono::seconds(5);
+}  // namespace
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_MappingCommon_detectInput(
+    JNIEnv* env, jclass, jobject j_emulated_controller, jboolean all_devices)
+{
+  ControllerEmu::EmulatedController* emulated_controller =
+      EmulatedControllerFromJava(env, j_emulated_controller);
+
+  const ciface::Core::DeviceQualifier default_device = emulated_controller->GetDefaultDevice();
+
+  std::vector<std::string> device_strings;
+  if (all_devices)
+    device_strings = g_controller_interface.GetAllDeviceStrings();
+  else
+    device_strings = {default_device.ToString()};
+
+  auto detections =
+      g_controller_interface.DetectInput(device_strings, INPUT_DETECT_INITIAL_TIME,
+                                         INPUT_DETECT_CONFIRMATION_TIME, INPUT_DETECT_MAXIMUM_TIME);
+
+  ciface::MappingCommon::RemoveSpuriousTriggerCombinations(&detections);
+
+  return ToJString(env, ciface::MappingCommon::BuildExpression(detections, default_device,
+                                                               ciface::MappingCommon::Quote::On));
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_MappingCommon_getExpressionForControl(
+    JNIEnv* env, jclass, jstring j_control, jstring j_device, jstring j_default_device)
+{
+  ciface::Core::DeviceQualifier device_qualifier, default_device_qualifier;
+  device_qualifier.FromString(GetJString(env, j_device));
+  default_device_qualifier.FromString(GetJString(env, j_default_device));
+
+  return ToJString(env, ciface::MappingCommon::GetExpressionForControl(GetJString(env, j_control),
+                                                                       device_qualifier,
+                                                                       default_device_qualifier));
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_MappingCommon_save(JNIEnv* env, jclass)
+{
+  Pad::GetConfig()->SaveConfig();
+  Pad::GetGBAConfig()->SaveConfig();
+  Keyboard::GetConfig()->SaveConfig();
+  Wiimote::GetConfig()->SaveConfig();
+  HotkeyManagerEmu::GetConfig()->SaveConfig();
+  FreeLook::GetInputConfig()->SaveConfig();
+}
+};

Source/Android/jni/Input/NumericSetting.cpp

@@ -0,0 +1,160 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "jni/Input/NumericSetting.h"
+
+#include <string>
+
+#include <jni.h>
+
+#include "Common/Assert.h"
+#include "Common/MsgHandler.h"
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Setting/NumericSetting.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+#include "jni/Input/ControlReference.h"
+
+static const char* NullStringToEmptyString(const char* str)
+{
+  return str ? str : "";
+}
+
+static ControllerEmu::NumericSettingBase* GetPointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ControllerEmu::NumericSettingBase*>(
+      env->GetLongField(obj, IDCache::GetNumericSettingPointer()));
+}
+
+template <typename T>
+static ControllerEmu::NumericSetting<T>* GetPointer(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<ControllerEmu::NumericSetting<T>*>(
+      env->GetLongField(obj, IDCache::GetNumericSettingPointer()));
+}
+
+jobject NumericSettingToJava(JNIEnv* env, ControllerEmu::NumericSettingBase* numeric_setting)
+{
+  if (!numeric_setting)
+    return nullptr;
+
+  return env->NewObject(IDCache::GetNumericSettingClass(), IDCache::GetNumericSettingConstructor(),
+                        reinterpret_cast<jlong>(numeric_setting));
+}
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getUiName(
+    JNIEnv* env, jobject obj)
+{
+  return ToJString(env, Common::GetStringT(GetPointer(env, obj)->GetUIName()));
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getUiSuffix(
+    JNIEnv* env, jobject obj)
+{
+  const char* str = NullStringToEmptyString(GetPointer(env, obj)->GetUISuffix());
+  return ToJString(env, Common::GetStringT(str));
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getUiDescription(
+    JNIEnv* env, jobject obj)
+{
+  const char* str = NullStringToEmptyString(GetPointer(env, obj)->GetUIDescription());
+  return ToJString(env, Common::GetStringT(str));
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getType(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<int>(GetPointer(env, obj)->GetType());
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getControlReference(
+    JNIEnv* env, jobject obj)
+{
+  return ControlReferenceToJava(env, &GetPointer(env, obj)->GetInputReference());
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getIntValue(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<int>(env, obj)->GetValue();
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_setIntValue(
+    JNIEnv* env, jobject obj, jint value)
+{
+  GetPointer<int>(env, obj)->SetValue(value);
+}
+
+JNIEXPORT jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getIntDefaultValue(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<int>(env, obj)->GetDefaultValue();
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getDoubleValue(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<double>(env, obj)->GetValue();
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_setDoubleValue(
+    JNIEnv* env, jobject obj, jdouble value)
+{
+  GetPointer<double>(env, obj)->SetValue(value);
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getDoubleDefaultValue(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<double>(env, obj)->GetDefaultValue();
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getDoubleMin(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<double>(env, obj)->GetMinValue();
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getDoubleMax(
+    JNIEnv* env, jobject obj)
+{
+  return GetPointer<double>(env, obj)->GetMaxValue();
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getBooleanValue(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jboolean>(GetPointer<bool>(env, obj)->GetValue());
+}
+
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_setBooleanValue(
+    JNIEnv* env, jobject obj, jboolean value)
+{
+  GetPointer<bool>(env, obj)->SetValue(static_cast<bool>(value));
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_NumericSetting_getBooleanDefaultValue(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jboolean>(GetPointer<bool>(env, obj)->GetDefaultValue());
+}
+}

Source/Android/jni/Input/NumericSetting.h

@@ -0,0 +1,15 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <jni.h>
+
+namespace ControllerEmu
+{
+class NumericSettingBase;
+}
+
+class ControlReference;
+
+jobject NumericSettingToJava(JNIEnv* env, ControllerEmu::NumericSettingBase* control);

Source/Android/jni/MainAndroid.cpp

@@ -52,8 +52,6 @@
 #include "DiscIO/ScrubbedBlob.h"
 #include "DiscIO/Volume.h"
 
-#include "InputCommon/ControllerInterface/Android/Android.h"
-#include "InputCommon/ControllerInterface/Touch/ButtonManager.h"
 #include "InputCommon/GCAdapter.h"
 
 #include "UICommon/GameFile.h"
@@ -291,24 +289,6 @@ Java_org_dolphinemu_dolphinemu_NativeLibrary_IsRunningAndUnpaused(JNIEnv*, jclas
   return static_cast<jboolean>(Core::GetState() == Core::State::Running);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(
-    JNIEnv* env, jclass, jstring jDevice, jint Button, jint Action)
-{
-  return ButtonManager::GamepadEvent(GetJString(env, jDevice), Button, Action);
-}
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(
-    JNIEnv* env, jclass, jstring jDevice, jint Axis, jfloat Value)
-{
-  ButtonManager::GamepadAxisEvent(GetJString(env, jDevice), Axis, Value);
-}
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetMotionSensorsEnabled(
-    JNIEnv*, jclass, jboolean accelerometer_enabled, jboolean gyroscope_enabled)
-{
-  ciface::Android::SetMotionSensorsEnabled(accelerometer_enabled, gyroscope_enabled);
-}
-
 JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetVersionString(JNIEnv* env,
                                                                                         jclass)
 {
@@ -376,12 +356,6 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_utils_DirectoryInitializat
   File::SetSysDirectory(path);
 }
 
-JNIEXPORT void JNICALL
-Java_org_dolphinemu_dolphinemu_utils_DirectoryInitialization_CreateUserDirectories(JNIEnv*, jclass)
-{
-  UICommon::CreateDirectories();
-}
-
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetUserDirectory(
     JNIEnv* env, jclass, jstring jDirectory)
 {
@@ -505,12 +479,6 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_RefreshWiimo
   WiimoteReal::Refresh();
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_ReloadWiimoteConfig(JNIEnv*,
-                                                                                        jclass)
-{
-  Wiimote::LoadConfig();
-}
-
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_ReloadConfig(JNIEnv*, jclass)
 {
   SConfig::GetInstance().LoadSettings();
@@ -531,6 +499,7 @@ Java_org_dolphinemu_dolphinemu_NativeLibrary_UpdateGCAdapterScanThread(JNIEnv*,
 
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Initialize(JNIEnv*, jclass)
 {
+  UICommon::CreateDirectories();
   Common::RegisterMsgAlertHandler(&MsgAlert);
   Common::AndroidSetReportHandler(&ReportSend);
   DolphinAnalytics::AndroidSetGetValFunc(&GetAnalyticValue);
@@ -584,8 +553,6 @@ static void Run(JNIEnv* env, std::unique_ptr<BootParameters>&& boot, bool riivol
 
   if (BootManager::BootCore(std::move(boot), wsi))
   {
-    ButtonManager::Init(SConfig::GetInstance().GetGameID());
-
     static constexpr int WAIT_STEP = 25;
     while (Core::GetState() == Core::State::Starting)
       std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_STEP));
@@ -605,7 +572,6 @@ static void Run(JNIEnv* env, std::unique_ptr<BootParameters>&& boot, bool riivol
 
   s_game_metadata_is_valid = false;
   Core::Shutdown();
-  ButtonManager::Shutdown();
   host_identity_guard.unlock();
 
   env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),