/
SDL_android.c
2483 lines (2068 loc) · 89.7 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"
#include "SDL_stdinc.h"
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_log.h"
26
#include "SDL_main.h"
27
28
29
30
31
32
#ifdef __ANDROID__
#include "SDL_system.h"
#include "SDL_android.h"
33
34
#include "keyinfotable.h"
35
36
37
38
39
40
41
#include "../../events/SDL_events_c.h"
#include "../../video/android/SDL_androidkeyboard.h"
#include "../../video/android/SDL_androidmouse.h"
#include "../../video/android/SDL_androidtouch.h"
#include "../../video/android/SDL_androidvideo.h"
#include "../../video/android/SDL_androidwindow.h"
#include "../../joystick/android/SDL_sysjoystick_c.h"
42
#include "../../haptic/android/SDL_syshaptic_c.h"
43
44
45
46
47
#include <android/log.h>
#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>
48
#include <dlfcn.h>
49
/* #define LOG_TAG "SDL_android" */
50
51
52
53
54
/* #define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) */
/* #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) */
#define LOGI(...) do {} while (0)
#define LOGE(...) do {} while (0)
55
56
57
58
59
#define SDL_JAVA_PREFIX org_libsdl_app
#define CONCAT1(prefix, class, function) CONCAT2(prefix, class, function)
#define CONCAT2(prefix, class, function) Java_ ## prefix ## _ ## class ## _ ## function
#define SDL_JAVA_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLActivity, function)
60
61
#define SDL_JAVA_AUDIO_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLAudioManager, function)
#define SDL_JAVA_CONTROLLER_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLControllerManager, function)
62
63
#define SDL_JAVA_INTERFACE_INPUT_CONNECTION(function) CONCAT1(SDL_JAVA_PREFIX, SDLInputConnection, function)
64
65
66
67
/* Audio encoding definitions */
#define ENCODING_PCM_8BIT 3
#define ENCODING_PCM_16BIT 2
#define ENCODING_PCM_FLOAT 4
68
69
/* Java class SDLActivity */
70
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(
71
JNIEnv *mEnv, jclass cls);
72
73
JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(
74
JNIEnv *env, jclass cls,
75
76
jstring library, jstring function, jobject array);
77
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
78
JNIEnv *env, jclass jcls,
79
80
81
jstring filename);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
82
JNIEnv *env, jclass jcls,
83
jint surfaceWidth, jint surfaceHeight,
84
jint deviceWidth, jint deviceHeight, jint format, jfloat rate);
85
86
87
88
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceCreated)(
JNIEnv *env, jclass jcls);
89
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(
90
JNIEnv *env, jclass jcls);
91
92
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(
93
JNIEnv *env, jclass jcls);
94
95
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
96
JNIEnv *env, jclass jcls,
97
98
99
jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
100
JNIEnv *env, jclass jcls,
101
102
103
jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
104
JNIEnv *env, jclass jcls);
105
106
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
107
JNIEnv *env, jclass jcls,
108
109
110
111
jint touch_device_id_in, jint pointer_finger_id_in,
jint action, jfloat x, jfloat y, jfloat p);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
112
JNIEnv *env, jclass jcls,
113
jint button, jint action, jfloat x, jfloat y, jboolean relative);
114
115
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
116
JNIEnv *env, jclass jcls,
117
118
jfloat x, jfloat y, jfloat z);
119
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
120
JNIEnv *env, jclass jcls);
121
122
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
123
JNIEnv *env, jclass cls);
124
125
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
126
JNIEnv *env, jclass cls);
127
128
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
129
JNIEnv *env, jclass cls);
130
131
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
132
JNIEnv *env, jclass cls);
133
134
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
135
JNIEnv *env, jclass cls,
136
137
jstring name);
138
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
139
JNIEnv *env, jclass cls,
140
141
142
jstring name, jstring value);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeEnvironmentVariablesSet)(
143
JNIEnv *env, jclass cls);
144
145
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
146
JNIEnv *env, jclass cls,
147
148
jint orientation);
149
150
/* Java class SDLInputConnection */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
151
JNIEnv *env, jclass cls,
152
153
jstring text, jint newCursorPosition);
154
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
155
JNIEnv *env, jclass cls,
156
157
jchar chUnicode);
158
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
159
JNIEnv *env, jclass cls,
160
161
jstring text, jint newCursorPosition);
162
163
164
165
166
167
168
169
170
/* Java class SDLAudioManager */
JNIEXPORT void JNICALL SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI)(
JNIEnv *env, jclass jcls);
/* Java class SDLControllerManager */
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(
JNIEnv *env, jclass jcls);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown)(
171
JNIEnv *env, jclass jcls,
172
173
174
jint device_id, jint keycode);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
175
JNIEnv *env, jclass jcls,
176
177
178
jint device_id, jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
179
JNIEnv *env, jclass jcls,
180
181
182
jint device_id, jint axis, jfloat value);
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
183
JNIEnv *env, jclass jcls,
184
185
186
jint device_id, jint hat_id, jint x, jint y);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
187
JNIEnv *env, jclass jcls,
188
189
jint device_id, jstring device_name, jstring device_desc, jint vendor_id, jint product_id,
jboolean is_accelerometer, jint button_mask, jint naxes, jint nhats, jint nballs);
190
191
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
192
JNIEnv *env, jclass jcls,
193
194
195
jint device_id);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
196
JNIEnv *env, jclass jcls,
197
198
199
jint device_id, jstring device_name);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
200
JNIEnv *env, jclass jcls,
201
202
203
jint device_id);
204
205
206
207
/* Uncomment this to log messages entering and exiting methods in this file */
/* #define DEBUG_JNI */
208
static void Android_JNI_ThreadDestroyed(void *);
209
static void checkJNIReady(void);
210
211
212
213
214
215
216
217
218
219
220
/*******************************************************************************
This file links the Java side of Android with libsdl
*******************************************************************************/
#include <jni.h>
/*******************************************************************************
Globals
*******************************************************************************/
static pthread_key_t mThreadKey;
221
static JavaVM *mJavaVM;
222
223
224
225
226
227
/* Main activity */
static jclass mActivityClass;
/* method signatures */
static jmethodID midGetNativeSurface;
228
static jmethodID midSetSurfaceViewFormat;
229
static jmethodID midSetActivityTitle;
230
static jmethodID midSetWindowStyle;
231
232
static jmethodID midSetOrientation;
static jmethodID midGetContext;
233
static jmethodID midIsTablet;
234
static jmethodID midIsAndroidTV;
235
static jmethodID midIsChromebook;
236
static jmethodID midIsDeXMode;
237
static jmethodID midManualBackButton;
238
239
240
241
static jmethodID midInputGetInputDeviceIds;
static jmethodID midSendMessage;
static jmethodID midShowTextInput;
static jmethodID midIsScreenKeyboardShown;
242
243
244
static jmethodID midClipboardSetText;
static jmethodID midClipboardGetText;
static jmethodID midClipboardHasText;
245
static jmethodID midOpenAPKExpansionInputStream;
246
static jmethodID midGetManifestEnvironmentVariables;
247
static jmethodID midGetDisplayDPI;
248
249
250
static jmethodID midCreateCustomCursor;
static jmethodID midSetCustomCursor;
static jmethodID midSetSystemCursor;
251
252
static jmethodID midSupportsRelativeMouse;
static jmethodID midSetRelativeMouseEnabled;
253
254
255
256
257
258
259
/* audio manager */
static jclass mAudioManagerClass;
/* method signatures */
static jmethodID midAudioOpen;
static jmethodID midAudioWriteByteBuffer;
260
261
static jmethodID midAudioWriteShortBuffer;
static jmethodID midAudioWriteFloatBuffer;
262
263
264
static jmethodID midAudioClose;
static jmethodID midCaptureOpen;
static jmethodID midCaptureReadByteBuffer;
265
266
static jmethodID midCaptureReadShortBuffer;
static jmethodID midCaptureReadFloatBuffer;
267
268
269
270
271
272
273
274
275
static jmethodID midCaptureClose;
/* controller manager */
static jclass mControllerManagerClass;
/* method signatures */
static jmethodID midPollInputDevices;
static jmethodID midPollHapticDevices;
static jmethodID midHapticRun;
276
static jmethodID midHapticStop;
277
278
279
280
/* static fields */
static jfieldID fidSeparateMouseAndTouch;
281
282
283
284
/* Accelerometer data storage */
static float fLastAccelerometer[3];
static SDL_bool bHasNewData;
285
static SDL_bool bHasEnvironmentVariables = SDL_FALSE;
286
287
288
289
290
291
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
/* Library init */
292
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
293
294
295
296
{
JNIEnv *env;
mJavaVM = vm;
LOGI("JNI_OnLoad called");
297
if ((*mJavaVM)->GetEnv(mJavaVM, (void **) &env, JNI_VERSION_1_4) != JNI_OK) {
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
LOGE("Failed to get the environment using GetEnv()");
return -1;
}
/*
* Create mThreadKey so we can keep track of the JNIEnv assigned to each thread
* Refer to http://developer.android.com/guide/practices/design/jni.html for the rationale behind this
*/
if (pthread_key_create(&mThreadKey, Android_JNI_ThreadDestroyed) != 0) {
__android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing pthread key");
}
Android_JNI_SetupThread();
return JNI_VERSION_1_4;
}
313
314
315
void checkJNIReady()
{
if (!mActivityClass || !mAudioManagerClass || !mControllerManagerClass) {
316
/* We aren't fully initialized, let's just return. */
317
318
319
return;
}
320
SDL_SetMainReady();
321
322
323
}
/* Activity initialization -- called before SDL_main() to initialize JNI bindings */
324
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *mEnv, jclass cls)
325
{
326
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeSetupJNI()");
327
328
/* Use a mutex to prevent concurrency issues between Java Activity and Native thread code, when using 'Android_Window'.
329
330
* (Eg. Java sending Touch events, while native code is destroying the main SDL_Window. )
*/
331
332
if (Android_ActivityMutex == NULL) {
Android_ActivityMutex = SDL_CreateMutex(); /* Could this be created twice if onCreate() is called a second time ? */
333
334
}
335
336
if (Android_ActivityMutex == NULL) {
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "failed to create Android_ActivityMutex mutex");
337
338
}
339
340
341
342
343
344
Android_JNI_SetupThread();
mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
midGetNativeSurface = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"getNativeSurface","()Landroid/view/Surface;");
345
346
midSetSurfaceViewFormat = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setSurfaceViewFormat","(I)V");
347
348
midSetActivityTitle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setActivityTitle","(Ljava/lang/String;)Z");
349
350
midSetWindowStyle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setWindowStyle","(Z)V");
351
352
353
354
midSetOrientation = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setOrientation","(IIZLjava/lang/String;)V");
midGetContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"getContext","()Landroid/content/Context;");
355
356
midIsTablet = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"isTablet", "()Z");
357
358
midIsAndroidTV = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"isAndroidTV","()Z");
359
360
midIsChromebook = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"isChromebook", "()Z");
361
362
midIsDeXMode = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"isDeXMode", "()Z");
363
364
midManualBackButton = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"manualBackButton", "()V");
365
366
367
368
369
370
371
372
midInputGetInputDeviceIds = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"inputGetInputDeviceIds", "(I)[I");
midSendMessage = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"sendMessage", "(II)Z");
midShowTextInput = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"showTextInput", "(IIII)Z");
midIsScreenKeyboardShown = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"isScreenKeyboardShown","()Z");
373
374
375
376
377
378
midClipboardSetText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"clipboardSetText", "(Ljava/lang/String;)V");
midClipboardGetText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"clipboardGetText", "()Ljava/lang/String;");
midClipboardHasText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"clipboardHasText", "()Z");
379
380
midOpenAPKExpansionInputStream = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"openAPKExpansionInputStream", "(Ljava/lang/String;)Ljava/io/InputStream;");
381
382
midGetManifestEnvironmentVariables = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
383
"getManifestEnvironmentVariables", "()Z");
384
385
midGetDisplayDPI = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "getDisplayDPI", "()Landroid/util/DisplayMetrics;");
386
midCreateCustomCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "createCustomCursor", "([IIIII)I");
387
388
midSetCustomCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setCustomCursor", "(I)Z");
midSetSystemCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setSystemCursor", "(I)Z");
389
390
391
392
midSupportsRelativeMouse = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "supportsRelativeMouse", "()Z");
midSetRelativeMouseEnabled = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setRelativeMouseEnabled", "(Z)Z");
393
394
if (!midGetNativeSurface || !midSetSurfaceViewFormat ||
395
!midSetActivityTitle || !midSetWindowStyle || !midSetOrientation || !midGetContext || !midIsTablet || !midIsAndroidTV || !midInputGetInputDeviceIds ||
396
!midSendMessage || !midShowTextInput || !midIsScreenKeyboardShown ||
397
!midClipboardSetText || !midClipboardGetText || !midClipboardHasText ||
398
!midOpenAPKExpansionInputStream || !midGetManifestEnvironmentVariables || !midGetDisplayDPI ||
399
!midCreateCustomCursor || !midSetCustomCursor || !midSetSystemCursor || !midSupportsRelativeMouse || !midSetRelativeMouseEnabled ||
400
!midIsChromebook || !midIsDeXMode || !midManualBackButton) {
401
__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLActivity.java?");
402
}
403
404
fidSeparateMouseAndTouch = (*mEnv)->GetStaticFieldID(mEnv, mActivityClass, "mSeparateMouseAndTouch", "Z");
405
406
if (!fidSeparateMouseAndTouch) {
407
408
409
__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java static fields, do you have the latest version of SDLActivity.java?");
}
410
411
412
413
checkJNIReady();
}
/* Audio initialization -- called before SDL_main() to initialize JNI bindings */
414
JNIEXPORT void JNICALL SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI)(JNIEnv *mEnv, jclass cls)
415
416
417
418
419
420
421
422
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "AUDIO nativeSetupJNI()");
Android_JNI_SetupThread();
mAudioManagerClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
midAudioOpen = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
423
"audioOpen", "(IIII)[I");
424
425
midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"audioWriteByteBuffer", "([B)V");
426
427
428
429
midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"audioWriteShortBuffer", "([S)V");
midAudioWriteFloatBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"audioWriteFloatBuffer", "([F)V");
430
431
432
midAudioClose = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"audioClose", "()V");
midCaptureOpen = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
433
"captureOpen", "(IIII)[I");
434
435
midCaptureReadByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"captureReadByteBuffer", "([BZ)I");
436
437
438
439
midCaptureReadShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"captureReadShortBuffer", "([SZ)I");
midCaptureReadFloatBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"captureReadFloatBuffer", "([FZ)I");
440
441
442
midCaptureClose = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
"captureClose", "()V");
443
444
if (!midAudioOpen || !midAudioWriteByteBuffer || !midAudioWriteShortBuffer || !midAudioWriteFloatBuffer || !midAudioClose ||
!midCaptureOpen || !midCaptureReadByteBuffer || !midCaptureReadShortBuffer || !midCaptureReadFloatBuffer || !midCaptureClose) {
445
446
447
448
449
450
451
__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLAudioManager.java?");
}
checkJNIReady();
}
/* Controller initialization -- called before SDL_main() to initialize JNI bindings */
452
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(JNIEnv *mEnv, jclass cls)
453
454
455
456
457
458
459
460
461
462
463
464
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "CONTROLLER nativeSetupJNI()");
Android_JNI_SetupThread();
mControllerManagerClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
"pollInputDevices", "()V");
midPollHapticDevices = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
"pollHapticDevices", "()V");
midHapticRun = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
465
"hapticRun", "(IFI)V");
466
467
midHapticStop = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
"hapticStop", "(I)V");
468
469
if (!midPollInputDevices || !midPollHapticDevices || !midHapticRun || !midHapticStop) {
470
471
472
473
__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLControllerManager.java?");
}
checkJNIReady();
474
475
476
477
478
479
}
/* SDL main function prototype */
typedef int (*SDL_main_func)(int argc, char *argv[]);
/* Start up the SDL app */
480
JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(JNIEnv *env, jclass cls, jstring library, jstring function, jobject array)
481
482
483
484
485
{
int status = -1;
const char *library_file;
void *library_handle;
486
487
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeRunMain()");
488
489
490
491
492
493
494
495
496
497
498
499
500
library_file = (*env)->GetStringUTFChars(env, library, NULL);
library_handle = dlopen(library_file, RTLD_GLOBAL);
if (library_handle) {
const char *function_name;
SDL_main_func SDL_main;
function_name = (*env)->GetStringUTFChars(env, function, NULL);
SDL_main = (SDL_main_func)dlsym(library_handle, function_name);
if (SDL_main) {
int i;
int argc;
int len;
char **argv;
501
SDL_bool isstack;
502
503
504
/* Prepare the arguments. */
len = (*env)->GetArrayLength(env, array);
505
argv = SDL_small_alloc(char *, 1 + len + 1, &isstack); /* !!! FIXME: check for NULL */
506
507
508
509
510
511
argc = 0;
/* Use the name "app_process" so PHYSFS_platformCalcBaseDir() works.
https://bitbucket.org/MartinFelis/love-android-sdl2/issue/23/release-build-crash-on-start
*/
argv[argc++] = SDL_strdup("app_process");
for (i = 0; i < len; ++i) {
512
513
const char *utf;
char *arg = NULL;
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
jstring string = (*env)->GetObjectArrayElement(env, array, i);
if (string) {
utf = (*env)->GetStringUTFChars(env, string, 0);
if (utf) {
arg = SDL_strdup(utf);
(*env)->ReleaseStringUTFChars(env, string, utf);
}
(*env)->DeleteLocalRef(env, string);
}
if (!arg) {
arg = SDL_strdup("");
}
argv[argc++] = arg;
}
argv[argc] = NULL;
/* Run the application. */
status = SDL_main(argc, argv);
/* Release the arguments. */
for (i = 0; i < argc; ++i) {
SDL_free(argv[i]);
}
538
SDL_small_free(argv, isstack);
539
540
541
542
543
544
545
546
547
548
} else {
__android_log_print(ANDROID_LOG_ERROR, "SDL", "nativeRunMain(): Couldn't find function %s in library %s", function_name, library_file);
}
(*env)->ReleaseStringUTFChars(env, function, function_name);
dlclose(library_handle);
} else {
__android_log_print(ANDROID_LOG_ERROR, "SDL", "nativeRunMain(): Couldn't load library %s", library_file);
549
}
550
551
552
553
(*env)->ReleaseStringUTFChars(env, library, library_file);
/* Do not issue an exit or the whole application will terminate instead of just the SDL thread */
/* exit(status); */
554
555
return status;
556
557
558
}
/* Drop file */
559
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
560
JNIEnv *env, jclass jcls,
561
562
563
jstring filename)
{
const char *path = (*env)->GetStringUTFChars(env, filename, NULL);
564
SDL_SendDropFile(NULL, path);
565
(*env)->ReleaseStringUTFChars(env, filename, path);
566
SDL_SendDropComplete(NULL);
567
568
569
}
/* Resize */
570
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
571
JNIEnv *env, jclass jcls,
572
jint surfaceWidth, jint surfaceHeight,
573
jint deviceWidth, jint deviceHeight, jint format, jfloat rate)
574
{
575
SDL_LockMutex(Android_ActivityMutex);
576
577
Android_SetScreenResolution(Android_Window, surfaceWidth, surfaceHeight, deviceWidth, deviceHeight, format, rate);
578
579
SDL_UnlockMutex(Android_ActivityMutex);
580
581
}
582
583
584
585
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
JNIEnv *env, jclass jcls,
jint orientation)
{
586
587
588
589
590
SDL_VideoDevice *_this = SDL_GetVideoDevice();
if (_this) {
SDL_VideoDisplay *display = SDL_GetDisplay(0);
SDL_SendDisplayEvent(display, SDL_DISPLAYEVENT_ORIENTATION, orientation);
}
591
592
}
593
/* Paddown */
594
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown)(
595
JNIEnv *env, jclass jcls,
596
597
598
599
600
601
jint device_id, jint keycode)
{
return Android_OnPadDown(device_id, keycode);
}
/* Padup */
602
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
603
JNIEnv *env, jclass jcls,
604
jint device_id, jint keycode)
605
606
607
608
609
{
return Android_OnPadUp(device_id, keycode);
}
/* Joy */
610
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
611
JNIEnv *env, jclass jcls,
612
613
614
615
616
617
jint device_id, jint axis, jfloat value)
{
Android_OnJoy(device_id, axis, value);
}
/* POV Hat */
618
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
619
JNIEnv *env, jclass jcls,
620
621
622
623
624
625
jint device_id, jint hat_id, jint x, jint y)
{
Android_OnHat(device_id, hat_id, x, y);
}
626
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
627
JNIEnv *env, jclass jcls,
628
629
630
jint device_id, jstring device_name, jstring device_desc,
jint vendor_id, jint product_id, jboolean is_accelerometer,
jint button_mask, jint naxes, jint nhats, jint nballs)
631
632
633
{
int retval;
const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);
634
const char *desc = (*env)->GetStringUTFChars(env, device_desc, NULL);
635
636
retval = Android_AddJoystick(device_id, name, desc, vendor_id, product_id, is_accelerometer ? SDL_TRUE : SDL_FALSE, button_mask, naxes, nhats, nballs);
637
638
(*env)->ReleaseStringUTFChars(env, device_name, name);
639
(*env)->ReleaseStringUTFChars(env, device_desc, desc);
640
641
642
643
return retval;
}
644
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
645
JNIEnv *env, jclass jcls,
646
jint device_id)
647
648
649
650
{
return Android_RemoveJoystick(device_id);
}
651
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
652
JNIEnv *env, jclass jcls, jint device_id, jstring device_name)
653
654
655
656
657
658
659
660
661
662
663
{
int retval;
const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);
retval = Android_AddHaptic(device_id, name);
(*env)->ReleaseStringUTFChars(env, device_name, name);
return retval;
}
664
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
665
JNIEnv *env, jclass jcls, jint device_id)
666
667
668
669
{
return Android_RemoveHaptic(device_id);
}
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
/* Called from surfaceCreated() */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceCreated)(JNIEnv *env, jclass jcls)
{
SDL_LockMutex(Android_ActivityMutex);
if (Android_Window && Android_Window->driverdata)
{
SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
data->native_window = Android_JNI_GetNativeWindow();
if (data->native_window == NULL) {
SDL_SetError("Could not fetch native window from UI thread");
}
}
SDL_UnlockMutex(Android_ActivityMutex);
}
687
688
/* Called from surfaceChanged() */
689
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv *env, jclass jcls)
690
{
691
SDL_LockMutex(Android_ActivityMutex);
692
693
694
695
696
if (Android_Window && Android_Window->driverdata)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
697
698
699
700
/* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
if (data->egl_surface == EGL_NO_SURFACE) {
data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);
701
}
702
703
704
/* GL Context handling is done in the event loop because this function is run from the Java thread */
}
705
706
SDL_UnlockMutex(Android_ActivityMutex);
707
708
}
709
/* Called from surfaceDestroyed() */
710
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(JNIEnv *env, jclass jcls)
711
{
712
SDL_LockMutex(Android_ActivityMutex);
713
714
715
716
717
if (Android_Window && Android_Window->driverdata)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
718
719
720
721
722
/* We have to clear the current context and destroy the egl surface here
* Otherwise there's BAD_NATIVE_WINDOW errors coming from eglCreateWindowSurface on resume
* Ref: http://stackoverflow.com/questions/8762589/eglcreatewindowsurface-on-ics-and-switching-from-2d-to-3d
*/
723
724
725
726
727
728
if (data->egl_surface != EGL_NO_SURFACE) {
SDL_EGL_MakeCurrent(_this, NULL, NULL);
SDL_EGL_DestroySurface(_this, data->egl_surface);
data->egl_surface = EGL_NO_SURFACE;
}
729
730
731
732
733
734
if (data->native_window) {
ANativeWindow_release(data->native_window);
}
data->native_window = NULL;
735
/* GL Context handling is done in the event loop because this function is run from the Java thread */
736
}
737
738
SDL_UnlockMutex(Android_ActivityMutex);
739
740
741
}
/* Keydown */
742
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
743
JNIEnv *env, jclass jcls,
744
jint keycode)
745
746
747
748
749
{
Android_OnKeyDown(keycode);
}
/* Keyup */
750
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
751
JNIEnv *env, jclass jcls,
752
jint keycode)
753
754
755
756
757
{
Android_OnKeyUp(keycode);
}
/* Keyboard Focus Lost */
758
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
759
JNIEnv *env, jclass jcls)
760
761
762
763
764
765
766
{
/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
SDL_StopTextInput();
}
/* Touch */
767
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
768
JNIEnv *env, jclass jcls,
769
770
771
jint touch_device_id_in, jint pointer_finger_id_in,
jint action, jfloat x, jfloat y, jfloat p)
{
772
SDL_LockMutex(Android_ActivityMutex);
773
774
Android_OnTouch(Android_Window, touch_device_id_in, pointer_finger_id_in, action, x, y, p);
775
776
SDL_UnlockMutex(Android_ActivityMutex);
777
778
779
}
/* Mouse */
780
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
781
JNIEnv *env, jclass jcls,
782
jint button, jint action, jfloat x, jfloat y, jboolean relative)
783
{
784
SDL_LockMutex(Android_ActivityMutex);
785
786
Android_OnMouse(Android_Window, button, action, x, y, relative);
787
788
SDL_UnlockMutex(Android_ActivityMutex);
789
790
791
}
/* Accelerometer */
792
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
793
JNIEnv *env, jclass jcls,
794
795
796
797
798
799
800
801
jfloat x, jfloat y, jfloat z)
{
fLastAccelerometer[0] = x;
fLastAccelerometer[1] = y;
fLastAccelerometer[2] = z;
bHasNewData = SDL_TRUE;
}
802
803
/* Clipboard */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
804
JNIEnv *env, jclass jcls)
805
806
807
808
{
SDL_SendClipboardUpdate();
}
809
/* Low memory */
810
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
811
JNIEnv *env, jclass cls)
812
813
814
815
816
{
SDL_SendAppEvent(SDL_APP_LOWMEMORY);
}
/* Quit */
817
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
818
JNIEnv *env, jclass cls)
819
820
821
822
823
824
825
826
{
/* Discard previous events. The user should have handled state storage
* in SDL_APP_WILLENTERBACKGROUND. After nativeQuit() is called, no
* events other than SDL_QUIT and SDL_APP_TERMINATING should fire */
SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
/* Inject a SDL_QUIT event */
SDL_SendQuit();
SDL_SendAppEvent(SDL_APP_TERMINATING);
827
828
829
830
/* Robustness: clear any pending Pause */
while (SDL_SemTryWait(Android_PauseSem) == 0) {
/* empty */
}
831
832
/* Resume the event loop so that the app can catch SDL_QUIT which
* should now be the top event in the event queue. */
833
SDL_SemPost(Android_ResumeSem);
834
835
836
}
/* Pause */
837
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
838
JNIEnv *env, jclass cls)
839
{
840
SDL_LockMutex(Android_ActivityMutex);
841
842
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");
843
844
845
846
847
848
if (Android_Window) {
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
SDL_SendAppEvent(SDL_APP_WILLENTERBACKGROUND);
SDL_SendAppEvent(SDL_APP_DIDENTERBACKGROUND);
849
850
/* *After* sending the relevant events, signal the pause semaphore
851
852
853
854
* so the event loop knows to pause and (optionally) block itself.
* Sometimes 2 pauses can be queued (eg pause/resume/pause), so it's
* always increased. */
SDL_SemPost(Android_PauseSem);
855
}
856
857
SDL_UnlockMutex(Android_ActivityMutex);
858
859
860
}
/* Resume */
861
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
862
JNIEnv *env, jclass cls)
863
{
864
SDL_LockMutex(Android_ActivityMutex);
865
866
867
868
869
870
871
872
873
874
875
876
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeResume()");
if (Android_Window) {
SDL_SendAppEvent(SDL_APP_WILLENTERFOREGROUND);
SDL_SendAppEvent(SDL_APP_DIDENTERFOREGROUND);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESTORED, 0, 0);
/* Signal the resume semaphore so the event loop knows to resume and restore the GL Context
* We can't restore the GL Context here because it needs to be done on the SDL main thread
* and this function will be called from the Java thread instead.
*/
877
SDL_SemPost(Android_ResumeSem);
878
}
879
880
SDL_UnlockMutex(Android_ActivityMutex);
881
882
}
883
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
884
JNIEnv *env, jclass cls,
885
886
887
888
889
890
891
892
893
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendKeyboardText(utftext);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
894
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
895
JNIEnv *env, jclass cls,
896
897
898
899
900
jchar chUnicode)
{
SDL_Scancode code = SDL_SCANCODE_UNKNOWN;
uint16_t mod = 0;
901
/* We do not care about bigger than 127. */
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
if (chUnicode < 127) {
AndroidKeyInfo info = unicharToAndroidKeyInfoTable[chUnicode];
code = info.code;
mod = info.mod;
}
if (mod & KMOD_SHIFT) {
/* If character uses shift, press shift down */
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT);
}
/* send a keydown and keyup even for the character */
SDL_SendKeyboardKey(SDL_PRESSED, code);
SDL_SendKeyboardKey(SDL_RELEASED, code);
if (mod & KMOD_SHIFT) {
/* If character uses shift, press shift back up */
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT);
}
}
924
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
925
JNIEnv *env, jclass cls,
926
927
928
929
930
931
932
933
934
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendEditingText(utftext, 0, 0);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
935
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
936
JNIEnv *env, jclass cls,
937
938
jstring name)
{
939
940
941
942
943
944
945
946
947
const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);
const char *hint = SDL_GetHint(utfname);
jstring result = (*env)->NewStringUTF(env, hint);
(*env)->ReleaseStringUTFChars(env, name, utfname);
return result;
}
948
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
949
JNIEnv *env, jclass cls,
950
951
952
953
954
955
956
957
958
959
960
961
jstring name, jstring value)
{
const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);
const char *utfvalue = (*env)->GetStringUTFChars(env, value, NULL);
SDL_setenv(utfname, utfvalue, 1);
(*env)->ReleaseStringUTFChars(env, name, utfname);
(*env)->ReleaseStringUTFChars(env, value, utfvalue);
}
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*******************************************************************************
Functions called by SDL into Java
*******************************************************************************/
static int s_active = 0;
struct LocalReferenceHolder
{
JNIEnv *m_env;
const char *m_func;
};
static struct LocalReferenceHolder LocalReferenceHolder_Setup(const char *func)
{
struct LocalReferenceHolder refholder;
refholder.m_env = NULL;
refholder.m_func = func;
#ifdef DEBUG_JNI
SDL_Log("Entering function %s", func);
#endif
return refholder;
}
static SDL_bool LocalReferenceHolder_Init(struct LocalReferenceHolder *refholder, JNIEnv *env)
{
const int capacity = 16;
if ((*env)->PushLocalFrame(env, capacity) < 0) {
SDL_SetError("Failed to allocate enough JVM local references");
return SDL_FALSE;
}
++s_active;
refholder->m_env = env;
return SDL_TRUE;
}
static void LocalReferenceHolder_Cleanup(struct LocalReferenceHolder *refholder)
{
#ifdef DEBUG_JNI
SDL_Log("Leaving function %s", refholder->m_func);
#endif