/
SDL_android.c
2480 lines (2065 loc) · 89.6 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
586
587
588
589
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
JNIEnv *env, jclass jcls,
jint orientation)
{
SDL_VideoDisplay *display = SDL_GetDisplay(0);
SDL_SendDisplayEvent(display, SDL_DISPLAYEVENT_ORIENTATION, orientation);
}
590
/* Paddown */
591
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown)(
592
JNIEnv *env, jclass jcls,
593
594
595
596
597
598
jint device_id, jint keycode)
{
return Android_OnPadDown(device_id, keycode);
}
/* Padup */
599
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
600
JNIEnv *env, jclass jcls,
601
jint device_id, jint keycode)
602
603
604
605
606
{
return Android_OnPadUp(device_id, keycode);
}
/* Joy */
607
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
608
JNIEnv *env, jclass jcls,
609
610
611
612
613
614
jint device_id, jint axis, jfloat value)
{
Android_OnJoy(device_id, axis, value);
}
/* POV Hat */
615
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
616
JNIEnv *env, jclass jcls,
617
618
619
620
621
622
jint device_id, jint hat_id, jint x, jint y)
{
Android_OnHat(device_id, hat_id, x, y);
}
623
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
624
JNIEnv *env, jclass jcls,
625
626
627
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)
628
629
630
{
int retval;
const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);
631
const char *desc = (*env)->GetStringUTFChars(env, device_desc, NULL);
632
633
retval = Android_AddJoystick(device_id, name, desc, vendor_id, product_id, is_accelerometer ? SDL_TRUE : SDL_FALSE, button_mask, naxes, nhats, nballs);
634
635
(*env)->ReleaseStringUTFChars(env, device_name, name);
636
(*env)->ReleaseStringUTFChars(env, device_desc, desc);
637
638
639
640
return retval;
}
641
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
642
JNIEnv *env, jclass jcls,
643
jint device_id)
644
645
646
647
{
return Android_RemoveJoystick(device_id);
}
648
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
649
JNIEnv *env, jclass jcls, jint device_id, jstring device_name)
650
651
652
653
654
655
656
657
658
659
660
{
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;
}
661
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
662
JNIEnv *env, jclass jcls, jint device_id)
663
664
665
666
{
return Android_RemoveHaptic(device_id);
}
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
/* 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);
}
684
685
/* Called from surfaceChanged() */
686
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv *env, jclass jcls)
687
{
688
SDL_LockMutex(Android_ActivityMutex);
689
690
691
692
693
if (Android_Window && Android_Window->driverdata)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
694
695
696
697
/* 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);
698
}
699
700
701
/* GL Context handling is done in the event loop because this function is run from the Java thread */
}
702
703
SDL_UnlockMutex(Android_ActivityMutex);
704
705
}
706
/* Called from surfaceDestroyed() */
707
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(JNIEnv *env, jclass jcls)
708
{
709
SDL_LockMutex(Android_ActivityMutex);
710
711
712
713
714
if (Android_Window && Android_Window->driverdata)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
715
716
717
718
719
/* 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
*/
720
721
722
723
724
725
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;
}
726
727
728
729
730
731
if (data->native_window) {
ANativeWindow_release(data->native_window);
}
data->native_window = NULL;
732
/* GL Context handling is done in the event loop because this function is run from the Java thread */
733
}
734
735
SDL_UnlockMutex(Android_ActivityMutex);
736
737
738
}
/* Keydown */
739
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
740
JNIEnv *env, jclass jcls,
741
jint keycode)
742
743
744
745
746
{
Android_OnKeyDown(keycode);
}
/* Keyup */
747
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
748
JNIEnv *env, jclass jcls,
749
jint keycode)
750
751
752
753
754
{
Android_OnKeyUp(keycode);
}
/* Keyboard Focus Lost */
755
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
756
JNIEnv *env, jclass jcls)
757
758
759
760
761
762
763
{
/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
SDL_StopTextInput();
}
/* Touch */
764
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
765
JNIEnv *env, jclass jcls,
766
767
768
jint touch_device_id_in, jint pointer_finger_id_in,
jint action, jfloat x, jfloat y, jfloat p)
{
769
SDL_LockMutex(Android_ActivityMutex);
770
771
Android_OnTouch(Android_Window, touch_device_id_in, pointer_finger_id_in, action, x, y, p);
772
773
SDL_UnlockMutex(Android_ActivityMutex);
774
775
776
}
/* Mouse */
777
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
778
JNIEnv *env, jclass jcls,
779
jint button, jint action, jfloat x, jfloat y, jboolean relative)
780
{
781
SDL_LockMutex(Android_ActivityMutex);
782
783
Android_OnMouse(Android_Window, button, action, x, y, relative);
784
785
SDL_UnlockMutex(Android_ActivityMutex);
786
787
788
}
/* Accelerometer */
789
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
790
JNIEnv *env, jclass jcls,
791
792
793
794
795
796
797
798
jfloat x, jfloat y, jfloat z)
{
fLastAccelerometer[0] = x;
fLastAccelerometer[1] = y;
fLastAccelerometer[2] = z;
bHasNewData = SDL_TRUE;
}
799
800
/* Clipboard */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
801
JNIEnv *env, jclass jcls)
802
803
804
805
{
SDL_SendClipboardUpdate();
}
806
/* Low memory */
807
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
808
JNIEnv *env, jclass cls)
809
810
811
812
813
{
SDL_SendAppEvent(SDL_APP_LOWMEMORY);
}
/* Quit */
814
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
815
JNIEnv *env, jclass cls)
816
817
818
819
820
821
822
823
{
/* 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);
824
825
826
827
/* Robustness: clear any pending Pause */
while (SDL_SemTryWait(Android_PauseSem) == 0) {
/* empty */
}
828
829
/* Resume the event loop so that the app can catch SDL_QUIT which
* should now be the top event in the event queue. */
830
SDL_SemPost(Android_ResumeSem);
831
832
833
}
/* Pause */
834
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
835
JNIEnv *env, jclass cls)
836
{
837
SDL_LockMutex(Android_ActivityMutex);
838
839
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");
840
841
842
843
844
845
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);
846
847
/* *After* sending the relevant events, signal the pause semaphore
848
849
850
851
* 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);
852
}
853
854
SDL_UnlockMutex(Android_ActivityMutex);
855
856
857
}
/* Resume */
858
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
859
JNIEnv *env, jclass cls)
860
{
861
SDL_LockMutex(Android_ActivityMutex);
862
863
864
865
866
867
868
869
870
871
872
873
__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.
*/
874
SDL_SemPost(Android_ResumeSem);
875
}
876
877
SDL_UnlockMutex(Android_ActivityMutex);
878
879
}
880
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
881
JNIEnv *env, jclass cls,
882
883
884
885
886
887
888
889
890
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendKeyboardText(utftext);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
891
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
892
JNIEnv *env, jclass cls,
893
894
895
896
897
jchar chUnicode)
{
SDL_Scancode code = SDL_SCANCODE_UNKNOWN;
uint16_t mod = 0;
898
/* We do not care about bigger than 127. */
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
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);
}
}
921
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
922
JNIEnv *env, jclass cls,
923
924
925
926
927
928
929
930
931
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendEditingText(utftext, 0, 0);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
932
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
933
JNIEnv *env, jclass cls,
934
935
jstring name)
{
936
937
938
939
940
941
942
943
944
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;
}
945
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
946
JNIEnv *env, jclass cls,
947
948
949
950
951
952
953
954
955
956
957
958
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);
}
959
960
961
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
/*******************************************************************************
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
if (refholder->m_env) {
999
JNIEnv *env = refholder->m_env;
1000
(*env)->PopLocalFrame(env, NULL);