Skip to content

Commit 23cea1b

Browse files
m4gr3dm4gr3d
committedDec 18, 2024·
Additional fixes and improvements to JavaClassWrapper
- Fix crashing bug when invoking class constructor with parameters - Add support for accessing class constants - Add support for Godot Callable arguments. A Godot Callable can be wrapped by a Java Runnable to allow Java logic to run arbitrary Godot lambdas - Automatically convert java.lang.CharSequence to Godot String as needed - Code cleanup
·
4.4.1-stable4.4-stable
1 parent 6e2cf2a commit 23cea1b

19 files changed

+526
-126
lines changed
 

‎platform/android/SCsub

+1
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ android_files = [
2828
"display_server_android.cpp",
2929
"plugin/godot_plugin_jni.cpp",
3030
"rendering_context_driver_vulkan_android.cpp",
31+
"variant/callable_jni.cpp",
3132
]
3233

3334
env_android = env.Clone()

‎platform/android/api/api.cpp

+3
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,9 @@ void JavaClassWrapper::_bind_methods() {
7373
}
7474

7575
#if !defined(ANDROID_ENABLED)
76+
bool JavaClass::_get(const StringName &p_name, Variant &r_ret) const {
77+
return false;
78+
}
7679

7780
Variant JavaClass::callp(const StringName &, const Variant **, int, Callable::CallError &) {
7881
return Variant();

‎platform/android/api/java_class_wrapper.h

+9
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,8 @@ class JavaClass : public RefCounted {
5858
ARG_TYPE_FLOAT,
5959
ARG_TYPE_DOUBLE,
6060
ARG_TYPE_STRING, //special case
61+
ARG_TYPE_CHARSEQUENCE,
62+
ARG_TYPE_CALLABLE,
6163
ARG_TYPE_CLASS,
6264
ARG_ARRAY_BIT = 1 << 16,
6365
ARG_NUMBER_CLASS_BIT = 1 << 17,
@@ -123,8 +125,12 @@ class JavaClass : public RefCounted {
123125
likelihood = 0.5;
124126
break;
125127
case ARG_TYPE_STRING:
128+
case ARG_TYPE_CHARSEQUENCE:
126129
r_type = Variant::STRING;
127130
break;
131+
case ARG_TYPE_CALLABLE:
132+
r_type = Variant::CALLABLE;
133+
break;
128134
case ARG_TYPE_CLASS:
129135
r_type = Variant::OBJECT;
130136
break;
@@ -163,9 +169,11 @@ class JavaClass : public RefCounted {
163169
likelihood = 0.5;
164170
break;
165171
case ARG_ARRAY_BIT | ARG_TYPE_STRING:
172+
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE:
166173
r_type = Variant::PACKED_STRING_ARRAY;
167174
break;
168175
case ARG_ARRAY_BIT | ARG_TYPE_CLASS:
176+
case ARG_ARRAY_BIT | ARG_TYPE_CALLABLE:
169177
r_type = Variant::ARRAY;
170178
break;
171179
}
@@ -185,6 +193,7 @@ class JavaClass : public RefCounted {
185193

186194
protected:
187195
static void _bind_methods();
196+
bool _get(const StringName &p_name, Variant &r_ret) const;
188197

189198
public:
190199
virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;

‎platform/android/dir_access_jandroid.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@
3030

3131
#include "dir_access_jandroid.h"
3232

33-
#include "string_android.h"
33+
#include "jni_utils.h"
3434
#include "thread_jandroid.h"
3535

3636
#include "core/string/print_string.h"

‎platform/android/java/lib/src/org/godotengine/godot/GodotLib.java

+13-2
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@
3535
import org.godotengine.godot.io.file.FileAccessHandler;
3636
import org.godotengine.godot.tts.GodotTTS;
3737
import org.godotengine.godot.utils.GodotNetUtils;
38+
import org.godotengine.godot.variant.Callable;
3839

3940
import android.app.Activity;
4041
import android.content.res.AssetManager;
@@ -200,16 +201,26 @@ public static native boolean initialize(Activity activity,
200201
* @param p_id Id of the Godot object to invoke
201202
* @param p_method Name of the method to invoke
202203
* @param p_params Parameters to use for method invocation
204+
*
205+
* @deprecated Use {@link Callable#call(long, String, Object...)} instead.
203206
*/
204-
public static native void callobject(long p_id, String p_method, Object[] p_params);
207+
@Deprecated
208+
public static void callobject(long p_id, String p_method, Object[] p_params) {
209+
Callable.call(p_id, p_method, p_params);
210+
}
205211

206212
/**
207213
* Invoke method |p_method| on the Godot object specified by |p_id| during idle time.
208214
* @param p_id Id of the Godot object to invoke
209215
* @param p_method Name of the method to invoke
210216
* @param p_params Parameters to use for method invocation
217+
*
218+
* @deprecated Use {@link Callable#callDeferred(long, String, Object...)} instead.
211219
*/
212-
public static native void calldeferred(long p_id, String p_method, Object[] p_params);
220+
@Deprecated
221+
public static void calldeferred(long p_id, String p_method, Object[] p_params) {
222+
Callable.callDeferred(p_id, p_method, p_params);
223+
}
213224

214225
/**
215226
* Forward the results from a permission request.

‎platform/android/java/lib/src/org/godotengine/godot/plugin/AndroidRuntimePlugin.kt

+39-1
Original file line numberDiff line numberDiff line change
@@ -31,14 +31,15 @@
3131
package org.godotengine.godot.plugin
3232

3333
import org.godotengine.godot.Godot
34+
import org.godotengine.godot.variant.Callable
3435

3536
/**
3637
* Provides access to the Android runtime capabilities.
3738
*
3839
* For example, from gdscript, developers can use [getApplicationContext] to access system services
3940
* and check if the device supports vibration.
4041
*
41-
* var android_runtime = Engine.get_singleton("AndroidRuntime")
42+
* var android_runtime = Engine.get_singleton("AndroidRuntime")
4243
* if android_runtime:
4344
* print("Checking if the device supports vibration")
4445
* var vibrator_service = android_runtime.getApplicationContext().getSystemService("vibrator")
@@ -51,13 +52,50 @@ import org.godotengine.godot.Godot
5152
* printerr("Unable to retrieve the vibrator service")
5253
* else:
5354
* printerr("Couldn't find AndroidRuntime singleton")
55+
*
56+
*
57+
* Or it can be used to display an Android native toast from gdscript
58+
*
59+
* var android_runtime = Engine.get_singleton("AndroidRuntime")
60+
* if android_runtime:
61+
* var activity = android_runtime.getActivity()
62+
*
63+
* var toastCallable = func ():
64+
* var ToastClass = JavaClassWrapper.wrap("android.widget.Toast")
65+
* ToastClass.makeText(activity, "This is a test", ToastClass.LENGTH_LONG).show()
66+
*
67+
* activity.runOnUiThread(android_runtime.createRunnableFromGodotCallable(toastCallable))
68+
* else:
69+
* printerr("Unable to access android runtime")
5470
*/
5571
class AndroidRuntimePlugin(godot: Godot) : GodotPlugin(godot) {
5672
override fun getPluginName() = "AndroidRuntime"
5773

74+
/**
75+
* Provides access to the application context to GDScript
76+
*/
5877
@UsedByGodot
5978
fun getApplicationContext() = activity?.applicationContext
6079

80+
/**
81+
* Provides access to the host activity to GDScript
82+
*/
6183
@UsedByGodot
6284
override fun getActivity() = super.getActivity()
85+
86+
/**
87+
* Utility method used to create [Runnable] from Godot [Callable].
88+
*/
89+
@UsedByGodot
90+
fun createRunnableFromGodotCallable(godotCallable: Callable): Runnable {
91+
return Runnable { godotCallable.call() }
92+
}
93+
94+
/**
95+
* Utility method used to create [java.util.concurrent.Callable] from Godot [Callable].
96+
*/
97+
@UsedByGodot
98+
fun createCallableFromGodotCallable(godotCallable: Callable): java.util.concurrent.Callable<Any> {
99+
return java.util.concurrent.Callable { godotCallable.call() }
100+
}
63101
}

‎platform/android/java/lib/src/org/godotengine/godot/variant/Callable.kt

+94
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
/**************************************************************************/
2+
/* Callable.kt */
3+
/**************************************************************************/
4+
/* This file is part of: */
5+
/* GODOT ENGINE */
6+
/* https://godotengine.org */
7+
/**************************************************************************/
8+
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9+
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
10+
/* */
11+
/* Permission is hereby granted, free of charge, to any person obtaining */
12+
/* a copy of this software and associated documentation files (the */
13+
/* "Software"), to deal in the Software without restriction, including */
14+
/* without limitation the rights to use, copy, modify, merge, publish, */
15+
/* distribute, sublicense, and/or sell copies of the Software, and to */
16+
/* permit persons to whom the Software is furnished to do so, subject to */
17+
/* the following conditions: */
18+
/* */
19+
/* The above copyright notice and this permission notice shall be */
20+
/* included in all copies or substantial portions of the Software. */
21+
/* */
22+
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23+
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24+
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25+
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26+
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27+
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28+
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29+
/**************************************************************************/
30+
31+
package org.godotengine.godot.variant
32+
33+
import androidx.annotation.Keep
34+
35+
/**
36+
* Android version of a Godot built-in Callable type representing a method or a standalone function.
37+
*/
38+
@Keep
39+
class Callable private constructor(private val nativeCallablePointer: Long) {
40+
41+
companion object {
42+
/**
43+
* Invoke method [methodName] on the Godot object specified by [godotObjectId]
44+
*/
45+
@JvmStatic
46+
fun call(godotObjectId: Long, methodName: String, vararg methodParameters: Any): Any? {
47+
return nativeCallObject(godotObjectId, methodName, methodParameters)
48+
}
49+
50+
/**
51+
* Invoke method [methodName] on the Godot object specified by [godotObjectId] during idle time.
52+
*/
53+
@JvmStatic
54+
fun callDeferred(godotObjectId: Long, methodName: String, vararg methodParameters: Any) {
55+
nativeCallObjectDeferred(godotObjectId, methodName, methodParameters)
56+
}
57+
58+
@JvmStatic
59+
private external fun nativeCall(pointer: Long, params: Array<out Any>): Any?
60+
61+
@JvmStatic
62+
private external fun nativeCallObject(godotObjectId: Long, methodName: String, params: Array<out Any>): Any?
63+
64+
@JvmStatic
65+
private external fun nativeCallObjectDeferred(godotObjectId: Long, methodName: String, params: Array<out Any>)
66+
67+
@JvmStatic
68+
private external fun releaseNativePointer(nativePointer: Long)
69+
}
70+
71+
/**
72+
* Calls the method represented by this [Callable]. Arguments can be passed and should match the method's signature.
73+
*/
74+
internal fun call(vararg params: Any): Any? {
75+
if (nativeCallablePointer == 0L) {
76+
return null
77+
}
78+
79+
return nativeCall(nativeCallablePointer, params)
80+
}
81+
82+
/**
83+
* Used to provide access to the native callable pointer to the native logic.
84+
*/
85+
private fun getNativePointer() = nativeCallablePointer
86+
87+
/** Note that [finalize] is deprecated and shouldn't be used, unfortunately its replacement,
88+
* [java.lang.ref.Cleaner], is only available on Android api 33 and higher.
89+
* So we resort to using it for the time being until our min api catches up to api 33.
90+
**/
91+
protected fun finalize() {
92+
releaseNativePointer(nativeCallablePointer)
93+
}
94+
}

‎platform/android/java_class_wrapper.cpp

+92-5
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@
3030

3131
#include "api/java_class_wrapper.h"
3232

33-
#include "string_android.h"
33+
#include "jni_utils.h"
3434
#include "thread_jandroid.h"
3535

3636
bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error, Variant &ret) {
@@ -96,11 +96,17 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
9696
arg_expected = Variant::FLOAT;
9797
}
9898
} break;
99-
case ARG_TYPE_STRING: {
99+
case ARG_TYPE_STRING:
100+
case ARG_TYPE_CHARSEQUENCE: {
100101
if (!p_args[i]->is_string()) {
101102
arg_expected = Variant::STRING;
102103
}
103104
} break;
105+
case ARG_TYPE_CALLABLE: {
106+
if (p_args[i]->get_type() != Variant::CALLABLE) {
107+
arg_expected = Variant::CALLABLE;
108+
}
109+
} break;
104110
case ARG_TYPE_CLASS: {
105111
if (p_args[i]->get_type() != Variant::OBJECT && p_args[i]->get_type() != Variant::NIL) {
106112
arg_expected = Variant::OBJECT;
@@ -265,12 +271,18 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
265271
argv[i].l = obj;
266272
to_free.push_back(obj);
267273
} break;
268-
case ARG_TYPE_STRING: {
274+
case ARG_TYPE_STRING:
275+
case ARG_TYPE_CHARSEQUENCE: {
269276
String s = *p_args[i];
270277
jstring jStr = env->NewStringUTF(s.utf8().get_data());
271278
argv[i].l = jStr;
272279
to_free.push_back(jStr);
273280
} break;
281+
case ARG_TYPE_CALLABLE: {
282+
jobject jcallable = callable_to_jcallable(env, *p_args[i]);
283+
argv[i].l = jcallable;
284+
to_free.push_back(jcallable);
285+
} break;
274286
case ARG_TYPE_CLASS: {
275287
Ref<JavaObject> jo = *p_args[i];
276288
if (jo.is_valid()) {
@@ -367,7 +379,8 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
367379
to_free.push_back(a);
368380

369381
} break;
370-
case ARG_ARRAY_BIT | ARG_TYPE_STRING: {
382+
case ARG_ARRAY_BIT | ARG_TYPE_STRING:
383+
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE: {
371384
Array arr = *p_args[i];
372385
jobjectArray a = env->NewObjectArray(arr.size(), env->FindClass("java/lang/String"), nullptr);
373386
for (int j = 0; j < arr.size(); j++) {
@@ -380,6 +393,19 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
380393
argv[i].l = a;
381394
to_free.push_back(a);
382395
} break;
396+
case ARG_ARRAY_BIT | ARG_TYPE_CALLABLE: {
397+
Array arr = *p_args[i];
398+
jobjectArray jarr = env->NewObjectArray(arr.size(), env->FindClass("org/godotengine/godot/variant/Callable"), nullptr);
399+
for (int j = 0; j < arr.size(); j++) {
400+
Variant callable = arr[j];
401+
jobject jcallable = callable_to_jcallable(env, callable);
402+
env->SetObjectArrayElement(jarr, j, jcallable);
403+
to_free.push_back(jcallable);
404+
}
405+
406+
argv[i].l = jarr;
407+
to_free.push_back(jarr);
408+
} break;
383409
case ARG_ARRAY_BIT | ARG_TYPE_CLASS: {
384410
argv[i].l = nullptr;
385411
} break;
@@ -463,7 +489,7 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
463489
default: {
464490
jobject obj;
465491
if (method->_constructor) {
466-
obj = env->NewObject(_class, method->method, argv);
492+
obj = env->NewObjectA(_class, method->method, argv);
467493
} else if (method->_static) {
468494
obj = env->CallStaticObjectMethodA(_class, method->method, argv);
469495
} else {
@@ -491,6 +517,15 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method,
491517
return success;
492518
}
493519

520+
bool JavaClass::_get(const StringName &p_name, Variant &r_ret) const {
521+
if (constant_map.has(p_name)) {
522+
r_ret = constant_map[p_name];
523+
return true;
524+
}
525+
526+
return false;
527+
}
528+
494529
Variant JavaClass::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
495530
Variant ret;
496531

@@ -706,6 +741,12 @@ bool JavaClassWrapper::_get_type_sig(JNIEnv *env, jobject obj, uint32_t &sig, St
706741
} else if (str_type == "java.lang.String") {
707742
t |= JavaClass::ARG_TYPE_STRING;
708743
strsig += "Ljava/lang/String;";
744+
} else if (str_type == "java.lang.CharSequence") {
745+
t |= JavaClass::ARG_TYPE_CHARSEQUENCE;
746+
strsig += "Ljava/lang/CharSequence;";
747+
} else if (str_type == "org.godotengine.godot.variant.Callable") {
748+
t |= JavaClass::ARG_TYPE_CALLABLE;
749+
strsig += "Lorg/godotengine/godot/variant/Callable;";
709750
} else if (str_type == "java.lang.Boolean") {
710751
t |= JavaClass::ARG_TYPE_BOOLEAN | JavaClass::ARG_NUMBER_CLASS_BIT;
711752
strsig += "Ljava/lang/Boolean;";
@@ -793,6 +834,14 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
793834
var = jstring_to_string((jstring)obj, env);
794835
return true;
795836
} break;
837+
case ARG_TYPE_CHARSEQUENCE: {
838+
var = charsequence_to_string(env, obj);
839+
return true;
840+
} break;
841+
case ARG_TYPE_CALLABLE: {
842+
var = jcallable_to_callable(env, obj);
843+
return true;
844+
} break;
796845
case ARG_TYPE_CLASS: {
797846
jclass java_class = env->GetObjectClass(obj);
798847
Ref<JavaClass> java_class_wrapped = JavaClassWrapper::singleton->wrap_jclass(java_class);
@@ -1113,6 +1162,44 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va
11131162
var = ret;
11141163
return true;
11151164
} break;
1165+
case ARG_ARRAY_BIT | ARG_TYPE_CHARSEQUENCE: {
1166+
Array ret;
1167+
jobjectArray arr = (jobjectArray)obj;
1168+
1169+
int count = env->GetArrayLength(arr);
1170+
1171+
for (int i = 0; i < count; i++) {
1172+
jobject o = env->GetObjectArrayElement(arr, i);
1173+
if (!o) {
1174+
ret.push_back(Variant());
1175+
} else {
1176+
String val = charsequence_to_string(env, o);
1177+
ret.push_back(val);
1178+
}
1179+
env->DeleteLocalRef(o);
1180+
}
1181+
1182+
var = ret;
1183+
return true;
1184+
} break;
1185+
case ARG_ARRAY_BIT | ARG_TYPE_CALLABLE: {
1186+
Array ret;
1187+
jobjectArray jarr = (jobjectArray)obj;
1188+
int count = env->GetArrayLength(jarr);
1189+
for (int i = 0; i < count; i++) {
1190+
jobject o = env->GetObjectArrayElement(jarr, i);
1191+
if (!o) {
1192+
ret.push_back(Variant());
1193+
} else {
1194+
Callable callable = jcallable_to_callable(env, o);
1195+
ret.push_back(callable);
1196+
}
1197+
env->DeleteLocalRef(o);
1198+
}
1199+
1200+
var = ret;
1201+
return true;
1202+
} break;
11161203
case ARG_ARRAY_BIT | ARG_TYPE_CLASS: {
11171204
} break;
11181205
}

‎platform/android/java_godot_io_wrapper.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@
3131
#ifndef JAVA_GODOT_IO_WRAPPER_H
3232
#define JAVA_GODOT_IO_WRAPPER_H
3333

34-
#include "string_android.h"
34+
#include "jni_utils.h"
3535

3636
#include "core/math/rect2i.h"
3737
#include "core/variant/typed_array.h"

‎platform/android/java_godot_lib_jni.cpp

-46
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,6 @@
4242
#include "net_socket_android.h"
4343
#include "os_android.h"
4444
#include "plugin/godot_plugin_jni.h"
45-
#include "string_android.h"
4645
#include "thread_jandroid.h"
4746
#include "tts_android.h"
4847

@@ -488,51 +487,6 @@ JNIEXPORT jstring JNICALL Java_org_godotengine_godot_GodotLib_getEditorSetting(J
488487
return env->NewStringUTF(editor_setting_value.utf8().get_data());
489488
}
490489

491-
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_callobject(JNIEnv *env, jclass clazz, jlong ID, jstring method, jobjectArray params) {
492-
Object *obj = ObjectDB::get_instance(ObjectID(ID));
493-
ERR_FAIL_NULL(obj);
494-
495-
String str_method = jstring_to_string(method, env);
496-
497-
int count = env->GetArrayLength(params);
498-
499-
Variant *vlist = (Variant *)alloca(sizeof(Variant) * count);
500-
const Variant **vptr = (const Variant **)alloca(sizeof(Variant *) * count);
501-
502-
for (int i = 0; i < count; i++) {
503-
jobject jobj = env->GetObjectArrayElement(params, i);
504-
ERR_FAIL_NULL(jobj);
505-
memnew_placement(&vlist[i], Variant(_jobject_to_variant(env, jobj)));
506-
vptr[i] = &vlist[i];
507-
env->DeleteLocalRef(jobj);
508-
}
509-
510-
Callable::CallError err;
511-
obj->callp(str_method, vptr, count, err);
512-
}
513-
514-
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_calldeferred(JNIEnv *env, jclass clazz, jlong ID, jstring method, jobjectArray params) {
515-
Object *obj = ObjectDB::get_instance(ObjectID(ID));
516-
ERR_FAIL_NULL(obj);
517-
518-
String str_method = jstring_to_string(method, env);
519-
520-
int count = env->GetArrayLength(params);
521-
522-
Variant *args = (Variant *)alloca(sizeof(Variant) * count);
523-
const Variant **argptrs = (const Variant **)alloca(sizeof(Variant *) * count);
524-
525-
for (int i = 0; i < count; i++) {
526-
jobject jobj = env->GetObjectArrayElement(params, i);
527-
ERR_FAIL_NULL(jobj);
528-
memnew_placement(&args[i], Variant(_jobject_to_variant(env, jobj)));
529-
argptrs[i] = &args[i];
530-
env->DeleteLocalRef(jobj);
531-
}
532-
533-
Callable(obj, str_method).call_deferredp(argptrs, count);
534-
}
535-
536490
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_onNightModeChanged(JNIEnv *env, jclass clazz) {
537491
DisplayServerAndroid *ds = (DisplayServerAndroid *)DisplayServer::get_singleton();
538492
if (ds) {

‎platform/android/java_godot_lib_jni.h

-2
Original file line numberDiff line numberDiff line change
@@ -62,8 +62,6 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_focusin(JNIEnv *env,
6262
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_focusout(JNIEnv *env, jclass clazz);
6363
JNIEXPORT jstring JNICALL Java_org_godotengine_godot_GodotLib_getGlobal(JNIEnv *env, jclass clazz, jstring path);
6464
JNIEXPORT jstring JNICALL Java_org_godotengine_godot_GodotLib_getEditorSetting(JNIEnv *env, jclass clazz, jstring p_setting_key);
65-
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_callobject(JNIEnv *env, jclass clazz, jlong ID, jstring method, jobjectArray params);
66-
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_calldeferred(JNIEnv *env, jclass clazz, jlong ID, jstring method, jobjectArray params);
6765
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_setVirtualKeyboardHeight(JNIEnv *env, jclass clazz, jint p_height);
6866
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_requestPermissionResult(JNIEnv *env, jclass clazz, jstring p_permission, jboolean p_result);
6967
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_onNightModeChanged(JNIEnv *env, jclass clazz);

‎platform/android/java_godot_view_wrapper.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@
3131
#ifndef JAVA_GODOT_VIEW_WRAPPER_H
3232
#define JAVA_GODOT_VIEW_WRAPPER_H
3333

34-
#include "string_android.h"
34+
#include "jni_utils.h"
3535

3636
#include "core/math/vector2.h"
3737

‎platform/android/java_godot_wrapper.h

-1
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,6 @@
3232
#define JAVA_GODOT_WRAPPER_H
3333

3434
#include "java_godot_view_wrapper.h"
35-
#include "string_android.h"
3635

3736
#include "core/math/color.h"
3837
#include "core/templates/list.h"

‎platform/android/jni_utils.cpp

+82-35
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,57 @@
3232

3333
#include "api/java_class_wrapper.h"
3434

35+
jobject callable_to_jcallable(JNIEnv *p_env, const Variant &p_callable) {
36+
ERR_FAIL_NULL_V(p_env, nullptr);
37+
if (p_callable.get_type() != Variant::CALLABLE) {
38+
return nullptr;
39+
}
40+
41+
Variant *callable_jcopy = memnew(Variant(p_callable));
42+
43+
jclass bclass = p_env->FindClass("org/godotengine/godot/variant/Callable");
44+
jmethodID ctor = p_env->GetMethodID(bclass, "<init>", "(J)V");
45+
jobject jcallable = p_env->NewObject(bclass, ctor, reinterpret_cast<int64_t>(callable_jcopy));
46+
p_env->DeleteLocalRef(bclass);
47+
48+
return jcallable;
49+
}
50+
51+
Callable jcallable_to_callable(JNIEnv *p_env, jobject p_jcallable_obj) {
52+
ERR_FAIL_NULL_V(p_env, Callable());
53+
54+
const Variant *callable_variant = nullptr;
55+
jclass callable_class = p_env->FindClass("org/godotengine/godot/variant/Callable");
56+
if (callable_class && p_env->IsInstanceOf(p_jcallable_obj, callable_class)) {
57+
jmethodID get_native_pointer = p_env->GetMethodID(callable_class, "getNativePointer", "()J");
58+
jlong native_callable = p_env->CallLongMethod(p_jcallable_obj, get_native_pointer);
59+
60+
callable_variant = reinterpret_cast<const Variant *>(native_callable);
61+
}
62+
63+
p_env->DeleteLocalRef(callable_class);
64+
65+
ERR_FAIL_NULL_V(callable_variant, Callable());
66+
return *callable_variant;
67+
}
68+
69+
String charsequence_to_string(JNIEnv *p_env, jobject p_charsequence) {
70+
ERR_FAIL_NULL_V(p_env, String());
71+
72+
String result;
73+
jclass bclass = p_env->FindClass("java/lang/CharSequence");
74+
if (bclass && p_env->IsInstanceOf(p_charsequence, bclass)) {
75+
jmethodID to_string = p_env->GetMethodID(bclass, "toString", "()Ljava/lang/String;");
76+
jstring obj_string = (jstring)p_env->CallObjectMethod(p_charsequence, to_string);
77+
78+
result = jstring_to_string(obj_string, p_env);
79+
p_env->DeleteLocalRef(obj_string);
80+
}
81+
82+
p_env->DeleteLocalRef(bclass);
83+
return result;
84+
}
85+
3586
jvalret _variant_to_jvalue(JNIEnv *env, Variant::Type p_type, const Variant *p_arg, bool force_jobject) {
3687
jvalret v;
3788

@@ -100,6 +151,12 @@ jvalret _variant_to_jvalue(JNIEnv *env, Variant::Type p_type, const Variant *p_a
100151

101152
} break;
102153

154+
case Variant::CALLABLE: {
155+
jobject jcallable = callable_to_jcallable(env, *p_arg);
156+
v.val.l = jcallable;
157+
v.obj = jcallable;
158+
} break;
159+
103160
case Variant::DICTIONARY: {
104161
Dictionary dict = *p_arg;
105162
jclass dclass = env->FindClass("org/godotengine/godot/Dictionary");
@@ -234,6 +291,10 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj) {
234291
return jstring_to_string((jstring)obj, env);
235292
}
236293

294+
if (name == "java.lang.CharSequence") {
295+
return charsequence_to_string(env, obj);
296+
}
297+
237298
if (name == "[Ljava.lang.String;") {
238299
jobjectArray arr = (jobjectArray)obj;
239300
int stringCount = env->GetArrayLength(arr);
@@ -248,6 +309,20 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj) {
248309
return sarr;
249310
}
250311

312+
if (name == "[Ljava.lang.CharSequence;") {
313+
jobjectArray arr = (jobjectArray)obj;
314+
int stringCount = env->GetArrayLength(arr);
315+
Vector<String> sarr;
316+
317+
for (int i = 0; i < stringCount; i++) {
318+
jobject charsequence = env->GetObjectArrayElement(arr, i);
319+
sarr.push_back(charsequence_to_string(env, charsequence));
320+
env->DeleteLocalRef(charsequence);
321+
}
322+
323+
return sarr;
324+
}
325+
251326
if (name == "java.lang.Boolean") {
252327
jmethodID boolValue = env->GetMethodID(c, "booleanValue", "()Z");
253328
bool ret = env->CallBooleanMethod(obj, boolValue);
@@ -370,6 +445,10 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj) {
370445
return ret;
371446
}
372447

448+
if (name == "org.godotengine.godot.variant.Callable") {
449+
return jcallable_to_callable(env, obj);
450+
}
451+
373452
Ref<JavaObject> generic_object(memnew(JavaObject(JavaClassWrapper::get_singleton()->wrap(name), obj)));
374453

375454
env->DeleteLocalRef(c);
@@ -389,13 +468,16 @@ Variant::Type get_jni_type(const String &p_type) {
389468
{ "float", Variant::FLOAT },
390469
{ "double", Variant::FLOAT },
391470
{ "java.lang.String", Variant::STRING },
471+
{ "java.lang.CharSequence", Variant::STRING },
392472
{ "[I", Variant::PACKED_INT32_ARRAY },
393473
{ "[J", Variant::PACKED_INT64_ARRAY },
394474
{ "[B", Variant::PACKED_BYTE_ARRAY },
395475
{ "[F", Variant::PACKED_FLOAT32_ARRAY },
396476
{ "[D", Variant::PACKED_FLOAT64_ARRAY },
397477
{ "[Ljava.lang.String;", Variant::PACKED_STRING_ARRAY },
478+
{ "[Ljava.lang.CharSequence;", Variant::PACKED_STRING_ARRAY },
398479
{ "org.godotengine.godot.Dictionary", Variant::DICTIONARY },
480+
{ "org.godotengine.godot.variant.Callable", Variant::CALLABLE },
399481
{ nullptr, Variant::NIL }
400482
};
401483

@@ -411,38 +493,3 @@ Variant::Type get_jni_type(const String &p_type) {
411493

412494
return Variant::OBJECT;
413495
}
414-
415-
String get_jni_sig(const String &p_type) {
416-
static struct {
417-
const char *name;
418-
const char *sig;
419-
} _type_to_vtype[] = {
420-
{ "void", "V" },
421-
{ "boolean", "Z" },
422-
{ "int", "I" },
423-
{ "long", "J" },
424-
{ "float", "F" },
425-
{ "double", "D" },
426-
{ "java.lang.String", "Ljava/lang/String;" },
427-
{ "org.godotengine.godot.Dictionary", "Lorg/godotengine/godot/Dictionary;" },
428-
{ "[I", "[I" },
429-
{ "[J", "[J" },
430-
{ "[B", "[B" },
431-
{ "[F", "[F" },
432-
{ "[D", "[D" },
433-
{ "[Ljava.lang.String;", "[Ljava/lang/String;" },
434-
{ nullptr, "V" }
435-
};
436-
437-
int idx = 0;
438-
439-
while (_type_to_vtype[idx].name) {
440-
if (p_type == _type_to_vtype[idx].name) {
441-
return _type_to_vtype[idx].sig;
442-
}
443-
444-
idx++;
445-
}
446-
447-
return "L" + p_type.replace(".", "/") + ";";
448-
}

‎platform/android/jni_utils.h

+46-2
Original file line numberDiff line numberDiff line change
@@ -31,9 +31,10 @@
3131
#ifndef JNI_UTILS_H
3232
#define JNI_UTILS_H
3333

34-
#include "string_android.h"
34+
#include "thread_jandroid.h"
3535

3636
#include "core/config/engine.h"
37+
#include "core/string/ustring.h"
3738
#include "core/variant/variant.h"
3839

3940
#include <jni.h>
@@ -52,6 +53,49 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj);
5253

5354
Variant::Type get_jni_type(const String &p_type);
5455

55-
String get_jni_sig(const String &p_type);
56+
/**
57+
* Convert a Godot Callable to a org.godotengine.godot.variant.Callable java object.
58+
* @param p_env JNI environment instance
59+
* @param p_callable Callable parameter to convert. If null or invalid type, a null jobject is returned.
60+
* @return org.godotengine.godot.variant.Callable jobject or null
61+
*/
62+
jobject callable_to_jcallable(JNIEnv *p_env, const Variant &p_callable);
63+
64+
/**
65+
* Convert a org.godotengine.godot.variant.Callable java object to a Godot Callable variant.
66+
* @param p_env JNI environment instance
67+
* @param p_jcallable_obj org.godotengine.godot.variant.Callable java object to convert.
68+
* @return Callable variant
69+
*/
70+
Callable jcallable_to_callable(JNIEnv *p_env, jobject p_jcallable_obj);
71+
72+
/**
73+
* Converts a java.lang.CharSequence object to a Godot String.
74+
* @param p_env JNI environment instance
75+
* @param p_charsequence java.lang.CharSequence object to convert
76+
* @return Godot String instance.
77+
*/
78+
String charsequence_to_string(JNIEnv *p_env, jobject p_charsequence);
79+
80+
/**
81+
* Converts JNI jstring to Godot String.
82+
* @param source Source JNI string. If null an empty string is returned.
83+
* @param env JNI environment instance. If null obtained by get_jni_env().
84+
* @return Godot string instance.
85+
*/
86+
static inline String jstring_to_string(jstring source, JNIEnv *env = nullptr) {
87+
String result;
88+
if (source) {
89+
if (!env) {
90+
env = get_jni_env();
91+
}
92+
const char *const source_utf8 = env->GetStringUTFChars(source, nullptr);
93+
if (source_utf8) {
94+
result.parse_utf8(source_utf8);
95+
env->ReleaseStringUTFChars(source, source_utf8);
96+
}
97+
}
98+
return result;
99+
}
56100

57101
#endif // JNI_UTILS_H

‎platform/android/plugin/godot_plugin_jni.cpp

+5-1
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,6 @@
3333
#include "api/java_class_wrapper.h"
3434
#include "api/jni_singleton.h"
3535
#include "jni_utils.h"
36-
#include "string_android.h"
3736

3837
#include "core/config/engine.h"
3938
#include "core/error/error_macros.h"
@@ -136,5 +135,10 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_plugin_GodotPlugin_nativeEmitS
136135
}
137136

138137
singleton->emit_signalp(StringName(signal_name), args, count);
138+
139+
// Manually invoke the destructor to decrease the reference counts for the variant arguments.
140+
for (int i = 0; i < count; i++) {
141+
variant_params[i].~Variant();
142+
}
139143
}
140144
}

‎platform/android/tts_android.cpp

-1
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,6 @@
3232

3333
#include "java_godot_wrapper.h"
3434
#include "os_android.h"
35-
#include "string_android.h"
3635
#include "thread_jandroid.h"
3736

3837
bool TTS_Android::initialized = false;

‎platform/android/variant/callable_jni.cpp

+130
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
/**************************************************************************/
2+
/* callable_jni.cpp */
3+
/**************************************************************************/
4+
/* This file is part of: */
5+
/* GODOT ENGINE */
6+
/* https://godotengine.org */
7+
/**************************************************************************/
8+
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9+
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
10+
/* */
11+
/* Permission is hereby granted, free of charge, to any person obtaining */
12+
/* a copy of this software and associated documentation files (the */
13+
/* "Software"), to deal in the Software without restriction, including */
14+
/* without limitation the rights to use, copy, modify, merge, publish, */
15+
/* distribute, sublicense, and/or sell copies of the Software, and to */
16+
/* permit persons to whom the Software is furnished to do so, subject to */
17+
/* the following conditions: */
18+
/* */
19+
/* The above copyright notice and this permission notice shall be */
20+
/* included in all copies or substantial portions of the Software. */
21+
/* */
22+
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23+
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24+
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25+
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26+
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27+
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28+
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29+
/**************************************************************************/
30+
31+
#include "callable_jni.h"
32+
33+
#include "jni_utils.h"
34+
35+
#include "core/error/error_macros.h"
36+
#include "core/object/object.h"
37+
38+
static Callable _generate_callable(JNIEnv *p_env, jlong p_object_id, jstring p_method_name, jobjectArray p_parameters) {
39+
Object *obj = ObjectDB::get_instance(ObjectID(p_object_id));
40+
ERR_FAIL_NULL_V(obj, Callable());
41+
42+
String str_method = jstring_to_string(p_method_name, p_env);
43+
44+
int count = p_env->GetArrayLength(p_parameters);
45+
46+
Variant *args = (Variant *)alloca(sizeof(Variant) * count);
47+
const Variant **argptrs = (const Variant **)alloca(sizeof(Variant *) * count);
48+
49+
for (int i = 0; i < count; i++) {
50+
jobject jobj = p_env->GetObjectArrayElement(p_parameters, i);
51+
ERR_FAIL_NULL_V(jobj, Callable());
52+
memnew_placement(&args[i], Variant(_jobject_to_variant(p_env, jobj)));
53+
argptrs[i] = &args[i];
54+
p_env->DeleteLocalRef(jobj);
55+
}
56+
57+
Callable ret = Callable(obj, str_method).bindp(argptrs, count);
58+
59+
// Manually invoke the destructor to decrease the reference counts for the variant arguments.
60+
for (int i = 0; i < count; i++) {
61+
args[i].~Variant();
62+
}
63+
64+
return ret;
65+
}
66+
67+
extern "C" {
68+
JNIEXPORT jobject JNICALL Java_org_godotengine_godot_variant_Callable_nativeCall(JNIEnv *p_env, jclass p_clazz, jlong p_native_callable, jobjectArray p_parameters) {
69+
const Variant *callable_variant = reinterpret_cast<const Variant *>(p_native_callable);
70+
ERR_FAIL_NULL_V(callable_variant, nullptr);
71+
if (callable_variant->get_type() != Variant::CALLABLE) {
72+
return nullptr;
73+
}
74+
75+
int count = p_env->GetArrayLength(p_parameters);
76+
77+
Variant *args = (Variant *)alloca(sizeof(Variant) * count);
78+
const Variant **argptrs = (const Variant **)alloca(sizeof(Variant *) * count);
79+
80+
for (int i = 0; i < count; i++) {
81+
jobject jobj = p_env->GetObjectArrayElement(p_parameters, i);
82+
ERR_FAIL_NULL_V(jobj, nullptr);
83+
memnew_placement(&args[i], Variant(_jobject_to_variant(p_env, jobj)));
84+
argptrs[i] = &args[i];
85+
p_env->DeleteLocalRef(jobj);
86+
}
87+
88+
Callable callable = *callable_variant;
89+
jobject ret = nullptr;
90+
if (callable.is_valid()) {
91+
Callable::CallError err;
92+
Variant result;
93+
callable.callp(argptrs, count, result, err);
94+
jvalret jresult = _variant_to_jvalue(p_env, result.get_type(), &result, true);
95+
ret = jresult.obj;
96+
}
97+
98+
// Manually invoke the destructor to decrease the reference counts for the variant arguments.
99+
for (int i = 0; i < count; i++) {
100+
args[i].~Variant();
101+
}
102+
103+
return ret;
104+
}
105+
106+
JNIEXPORT jobject JNICALL Java_org_godotengine_godot_variant_Callable_nativeCallObject(JNIEnv *p_env, jclass p_clazz, jlong p_object_id, jstring p_method_name, jobjectArray p_parameters) {
107+
Callable callable = _generate_callable(p_env, p_object_id, p_method_name, p_parameters);
108+
if (callable.is_valid()) {
109+
Variant result = callable.call();
110+
jvalret jresult = _variant_to_jvalue(p_env, result.get_type(), &result, true);
111+
return jresult.obj;
112+
} else {
113+
return nullptr;
114+
}
115+
}
116+
117+
JNIEXPORT void JNICALL Java_org_godotengine_godot_variant_Callable_nativeCallObjectDeferred(JNIEnv *p_env, jclass p_clazz, jlong p_object_id, jstring p_method_name, jobjectArray p_parameters) {
118+
Callable callable = _generate_callable(p_env, p_object_id, p_method_name, p_parameters);
119+
if (callable.is_valid()) {
120+
callable.call_deferred();
121+
}
122+
}
123+
124+
JNIEXPORT void JNICALL
125+
Java_org_godotengine_godot_variant_Callable_releaseNativePointer(JNIEnv *p_env, jclass clazz, jlong p_native_pointer) {
126+
Variant *variant = reinterpret_cast<Variant *>(p_native_pointer);
127+
ERR_FAIL_NULL(variant);
128+
memdelete(variant);
129+
}
130+
}

‎platform/android/string_android.h ‎platform/android/variant/callable_jni.h

+9-27
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/**************************************************************************/
2-
/* string_android.h */
2+
/* callable_jni.h */
33
/**************************************************************************/
44
/* This file is part of: */
55
/* GODOT ENGINE */
@@ -28,34 +28,16 @@
2828
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
2929
/**************************************************************************/
3030

31-
#ifndef STRING_ANDROID_H
32-
#define STRING_ANDROID_H
33-
34-
#include "thread_jandroid.h"
35-
36-
#include "core/string/ustring.h"
31+
#ifndef CALLABLE_JNI_H
32+
#define CALLABLE_JNI_H
3733

3834
#include <jni.h>
3935

40-
/**
41-
* Converts JNI jstring to Godot String.
42-
* @param source Source JNI string. If null an empty string is returned.
43-
* @param env JNI environment instance. If null obtained by get_jni_env().
44-
* @return Godot string instance.
45-
*/
46-
static inline String jstring_to_string(jstring source, JNIEnv *env = nullptr) {
47-
String result;
48-
if (source) {
49-
if (!env) {
50-
env = get_jni_env();
51-
}
52-
const char *const source_utf8 = env->GetStringUTFChars(source, nullptr);
53-
if (source_utf8) {
54-
result.parse_utf8(source_utf8);
55-
env->ReleaseStringUTFChars(source, source_utf8);
56-
}
57-
}
58-
return result;
36+
extern "C" {
37+
JNIEXPORT jobject JNICALL Java_org_godotengine_godot_variant_Callable_nativeCall(JNIEnv *p_env, jclass p_clazz, jlong p_native_callable, jobjectArray p_parameters);
38+
JNIEXPORT jobject JNICALL Java_org_godotengine_godot_variant_Callable_nativeCallObject(JNIEnv *p_env, jclass p_clazz, jlong p_object_id, jstring p_method_name, jobjectArray p_parameters);
39+
JNIEXPORT void JNICALL Java_org_godotengine_godot_variant_Callable_nativeCallObjectDeferred(JNIEnv *p_env, jclass p_clazz, jlong p_object_id, jstring p_method_name, jobjectArray p_parameters);
40+
JNIEXPORT void JNICALL Java_org_godotengine_godot_variant_Callable_releaseNativePointer(JNIEnv *p_env, jclass clazz, jlong p_native_pointer);
5941
}
6042

61-
#endif // STRING_ANDROID_H
43+
#endif // CALLABLE_JNI_H

0 commit comments

Comments
 (0)
Please sign in to comment.