Android: Add new input mapping implementation

Source/Android/jni/AndroidCommon/IDCache.cpp

@@ -83,6 +83,22 @@ 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_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;
+
 namespace IDCache
 {
 JNIEnv* GetEnvForThread()
@@ -383,6 +399,66 @@ 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;
+}
+
 }  // namespace IDCache
 
 extern "C" {
@@ -541,6 +617,35 @@ 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);
+
   return JNI_VERSION;
 }
 
@@ -568,5 +673,9 @@ 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);
 }
 }

Source/Android/jni/AndroidCommon/IDCache.h

@@ -82,4 +82,20 @@ 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();
+
 }  // namespace IDCache

Source/Android/jni/CMakeLists.txt

@@ -10,7 +10,15 @@ 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/EmulatedController.cpp
   Input/InputOverrider.cpp
+  Input/MappingCommon.cpp
   IniFile.cpp
   MainAndroid.cpp
   RiivolutionPatches.cpp
@@ -23,6 +31,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,51 @@
+// 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/ControlGroup.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#include "jni/AndroidCommon/IDCache.h"
+#include "jni/Input/Control.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_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());
+}
+}

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,54 @@
+// 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;
+}
+}

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/EmulatedController.cpp

@@ -0,0 +1,81 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <jni.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"
+
+static ControllerEmu::EmulatedController* GetPointer(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 jint JNICALL
+Java_org_dolphinemu_dolphinemu_features_input_model_controlleremu_EmulatedController_getGroupCount(
+    JNIEnv* env, jobject obj)
+{
+  return static_cast<jint>(GetPointer(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, GetPointer(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 GetPointer(env, obj)->UpdateSingleControlReference(
+      g_controller_interface, ControlReferenceFromJava(env, control_reference));
+}
+
+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());
+}
+}

Source/Android/jni/Input/MappingCommon.cpp

@@ -0,0 +1,56 @@
+// 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"
+
+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)
+{
+  const std::vector<std::string> device_strings = g_controller_interface.GetAllDeviceStrings();
+  const ciface::Core::DeviceQualifier default_device{};
+
+  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 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();
+}
+};