/
SDL_android.c
1885 lines (1565 loc) · 67.5 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2017 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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"
#ifdef __ANDROID__
#include "SDL_system.h"
#include "SDL_android.h"
#include <EGL/egl.h>
#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"
40
#include "../../haptic/android/SDL_syshaptic_c.h"
41
42
43
44
45
#include <android/log.h>
#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>
46
/* #define LOG_TAG "SDL_android" */
47
48
49
50
51
/* #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)
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#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)
#define SDL_JAVA_INTERFACE_INPUT_CONNECTION(function) CONCAT1(SDL_JAVA_PREFIX, SDLInputConnection, function)
/* Java class SDLActivity */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
JNIEnv* env, jclass jcls,
jstring filename);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
JNIEnv* env, jclass jcls,
jint width, jint height, jint format, jfloat rate);
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadDown)(
JNIEnv* env, jclass jcls,
jint device_id, jint keycode);
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadUp)(
JNIEnv* env, jclass jcls,
jint device_id, jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeJoy)(
JNIEnv* env, jclass jcls,
jint device_id, jint axis, jfloat value);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeHat)(
JNIEnv* env, jclass jcls,
jint device_id, jint hat_id, jint x, jint y);
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddJoystick)(
JNIEnv* env, jclass jcls,
87
jint device_id, jstring device_name, jstring device_desc, jint is_accelerometer,
88
89
90
91
92
93
jint nbuttons, jint naxes, jint nhats, jint nballs);
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveJoystick)(
JNIEnv* env, jclass jcls,
jint device_id);
94
95
96
97
98
99
100
101
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddHaptic)(
JNIEnv* env, jclass jcls,
jint device_id, jstring device_name);
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveHaptic)(
JNIEnv* env, jclass jcls,
jint device_id);
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(
JNIEnv* env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(
JNIEnv* env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
JNIEnv* env, jclass jcls,
jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
JNIEnv* env, jclass jcls,
jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
JNIEnv* env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
JNIEnv* env, jclass jcls,
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)(
JNIEnv* env, jclass jcls,
jint button, jint action, jfloat x, jfloat y);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
JNIEnv* env, jclass jcls,
jfloat x, jfloat y, jfloat z);
132
133
134
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
JNIEnv* env, jclass jcls);
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
JNIEnv* env, jclass cls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
JNIEnv* env, jclass cls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
JNIEnv* env, jclass cls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
JNIEnv* env, jclass cls);
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
JNIEnv* env, jclass cls,
jstring name);
/* Java class SDLInputConnection */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
/* Uncomment this to log messages entering and exiting methods in this file */
/* #define DEBUG_JNI */
static void Android_JNI_ThreadDestroyed(void*);
/*******************************************************************************
This file links the Java side of Android with libsdl
*******************************************************************************/
#include <jni.h>
/*******************************************************************************
Globals
*******************************************************************************/
static pthread_key_t mThreadKey;
static JavaVM* mJavaVM;
/* Main activity */
static jclass mActivityClass;
/* method signatures */
static jmethodID midGetNativeSurface;
183
static jmethodID midAudioOpen;
184
185
static jmethodID midAudioWriteShortBuffer;
static jmethodID midAudioWriteByteBuffer;
186
187
188
189
190
static jmethodID midAudioClose;
static jmethodID midCaptureOpen;
static jmethodID midCaptureReadShortBuffer;
static jmethodID midCaptureReadByteBuffer;
static jmethodID midCaptureClose;
191
static jmethodID midPollInputDevices;
192
193
static jmethodID midPollHapticDevices;
static jmethodID midHapticRun;
194
195
196
197
198
199
200
static jmethodID midSetActivityTitle;
static jmethodID midSetOrientation;
static jmethodID midGetContext;
static jmethodID midInputGetInputDeviceIds;
static jmethodID midSendMessage;
static jmethodID midShowTextInput;
static jmethodID midIsScreenKeyboardShown;
201
202
203
204
static jmethodID midClipboardSetText;
static jmethodID midClipboardGetText;
static jmethodID midClipboardHasText;
205
206
207
208
/* static fields */
static jfieldID fidSeparateMouseAndTouch;
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
/* Accelerometer data storage */
static float fLastAccelerometer[3];
static SDL_bool bHasNewData;
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
/* Library init */
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
{
JNIEnv *env;
mJavaVM = vm;
LOGI("JNI_OnLoad called");
if ((*mJavaVM)->GetEnv(mJavaVM, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
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;
}
/* Called before SDL_main() to initialize JNI bindings */
JNIEXPORT void JNICALL SDL_Android_Init(JNIEnv* mEnv, jclass cls)
{
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init()");
Android_JNI_SetupThread();
mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
midGetNativeSurface = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"getNativeSurface","()Landroid/view/Surface;");
250
251
midAudioOpen = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"audioOpen", "(IZZI)I");
252
253
254
255
midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"audioWriteShortBuffer", "([S)V");
midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"audioWriteByteBuffer", "([B)V");
256
257
258
259
260
261
262
263
264
265
midAudioClose = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"audioClose", "()V");
midCaptureOpen = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"captureOpen", "(IZZI)I");
midCaptureReadShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"captureReadShortBuffer", "([SZ)I");
midCaptureReadByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"captureReadByteBuffer", "([BZ)I");
midCaptureClose = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"captureClose", "()V");
266
267
midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"pollInputDevices", "()V");
268
269
270
271
midPollHapticDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"pollHapticDevices", "()V");
midHapticRun = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"hapticRun", "(II)V");
272
273
274
275
276
277
278
279
280
281
282
283
284
285
midSetActivityTitle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setActivityTitle","(Ljava/lang/String;)Z");
midSetOrientation = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"setOrientation","(IIZLjava/lang/String;)V");
midGetContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"getContext","()Landroid/content/Context;");
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");
286
287
288
289
290
291
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");
292
293
294
bHasNewData = SDL_FALSE;
295
if (!midGetNativeSurface ||
296
!midAudioOpen || !midAudioWriteShortBuffer || !midAudioWriteByteBuffer || !midAudioClose ||
297
!midCaptureOpen || !midCaptureReadShortBuffer || !midCaptureReadByteBuffer || !midCaptureClose ||
298
299
!midPollInputDevices || !midPollHapticDevices || !midHapticRun ||
!midSetActivityTitle || !midSetOrientation || !midGetContext || !midInputGetInputDeviceIds ||
300
301
!midSendMessage || !midShowTextInput || !midIsScreenKeyboardShown ||
!midClipboardSetText || !midClipboardGetText || !midClipboardHasText) {
302
303
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java callbacks, check that they're named and typed correctly");
}
304
305
fidSeparateMouseAndTouch = (*mEnv)->GetStaticFieldID(mEnv, mActivityClass, "mSeparateMouseAndTouch", "Z");
306
307
308
309
310
if (!fidSeparateMouseAndTouch) {
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java static fields, check that they're named and typed correctly");
}
311
312
313
314
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init() finished!");
}
/* Drop file */
315
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
316
317
318
319
JNIEnv* env, jclass jcls,
jstring filename)
{
const char *path = (*env)->GetStringUTFChars(env, filename, NULL);
320
SDL_SendDropFile(NULL, path);
321
(*env)->ReleaseStringUTFChars(env, filename, path);
322
SDL_SendDropComplete(NULL);
323
324
325
}
/* Resize */
326
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
327
328
329
330
331
332
333
JNIEnv* env, jclass jcls,
jint width, jint height, jint format, jfloat rate)
{
Android_SetScreenResolution(width, height, format, rate);
}
/* Paddown */
334
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadDown)(
335
336
337
338
339
340
341
JNIEnv* env, jclass jcls,
jint device_id, jint keycode)
{
return Android_OnPadDown(device_id, keycode);
}
/* Padup */
342
343
344
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadUp)(
JNIEnv* env, jclass jcls,
jint device_id, jint keycode)
345
346
347
348
349
{
return Android_OnPadUp(device_id, keycode);
}
/* Joy */
350
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeJoy)(
351
352
353
354
355
356
357
JNIEnv* env, jclass jcls,
jint device_id, jint axis, jfloat value)
{
Android_OnJoy(device_id, axis, value);
}
/* POV Hat */
358
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeHat)(
359
360
361
362
363
364
365
JNIEnv* env, jclass jcls,
jint device_id, jint hat_id, jint x, jint y)
{
Android_OnHat(device_id, hat_id, x, y);
}
366
367
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddJoystick)(
JNIEnv* env, jclass jcls,
368
jint device_id, jstring device_name, jstring device_desc, jint is_accelerometer,
369
jint nbuttons, jint naxes, jint nhats, jint nballs)
370
371
372
{
int retval;
const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);
373
const char *desc = (*env)->GetStringUTFChars(env, device_desc, NULL);
374
375
retval = Android_AddJoystick(device_id, name, desc, (SDL_bool) is_accelerometer, nbuttons, naxes, nhats, nballs);
376
377
(*env)->ReleaseStringUTFChars(env, device_name, name);
378
(*env)->ReleaseStringUTFChars(env, device_desc, desc);
379
380
381
382
return retval;
}
383
384
385
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveJoystick)(
JNIEnv* env, jclass jcls,
jint device_id)
386
387
388
389
{
return Android_RemoveJoystick(device_id);
}
390
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddHaptic)(
391
392
393
394
395
396
397
398
399
400
401
402
JNIEnv* env, jclass jcls, jint device_id, jstring device_name)
{
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;
}
403
JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveHaptic)(
404
405
406
407
408
JNIEnv* env, jclass jcls, jint device_id)
{
return Android_RemoveHaptic(device_id);
}
409
410
/* Surface Created */
411
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv* env, jclass jcls)
412
413
414
415
416
417
418
{
SDL_WindowData *data;
SDL_VideoDevice *_this;
if (Android_Window == NULL || Android_Window->driverdata == NULL ) {
return;
}
419
420
421
_this = SDL_GetVideoDevice();
data = (SDL_WindowData *) Android_Window->driverdata;
422
423
424
425
426
427
428
429
430
/* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
if (data->egl_surface == EGL_NO_SURFACE) {
if(data->native_window) {
ANativeWindow_release(data->native_window);
}
data->native_window = Android_JNI_GetNativeWindow();
data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);
}
431
432
/* GL Context handling is done in the event loop because this function is run from the Java thread */
433
434
435
436
}
/* Surface Destroyed */
437
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(JNIEnv* env, jclass jcls)
438
439
440
441
442
443
444
{
/* 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
*/
SDL_WindowData *data;
SDL_VideoDevice *_this;
445
446
447
448
if (Android_Window == NULL || Android_Window->driverdata == NULL ) {
return;
}
449
450
451
_this = SDL_GetVideoDevice();
data = (SDL_WindowData *) Android_Window->driverdata;
452
453
454
455
456
457
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;
}
458
459
460
461
462
463
/* GL Context handling is done in the event loop because this function is run from the Java thread */
}
/* Keydown */
464
465
466
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
JNIEnv* env, jclass jcls,
jint keycode)
467
468
469
470
471
{
Android_OnKeyDown(keycode);
}
/* Keyup */
472
473
474
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
JNIEnv* env, jclass jcls,
jint keycode)
475
476
477
478
479
{
Android_OnKeyUp(keycode);
}
/* Keyboard Focus Lost */
480
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
481
482
483
484
485
486
487
488
JNIEnv* env, jclass jcls)
{
/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
SDL_StopTextInput();
}
/* Touch */
489
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
490
491
492
493
494
495
496
497
JNIEnv* env, jclass jcls,
jint touch_device_id_in, jint pointer_finger_id_in,
jint action, jfloat x, jfloat y, jfloat p)
{
Android_OnTouch(touch_device_id_in, pointer_finger_id_in, action, x, y, p);
}
/* Mouse */
498
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
499
500
501
502
503
504
505
JNIEnv* env, jclass jcls,
jint button, jint action, jfloat x, jfloat y)
{
Android_OnMouse(button, action, x, y);
}
/* Accelerometer */
506
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
507
508
509
510
511
512
513
514
515
JNIEnv* env, jclass jcls,
jfloat x, jfloat y, jfloat z)
{
fLastAccelerometer[0] = x;
fLastAccelerometer[1] = y;
fLastAccelerometer[2] = z;
bHasNewData = SDL_TRUE;
}
516
517
518
519
520
521
522
/* Clipboard */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
JNIEnv* env, jclass jcls)
{
SDL_SendClipboardUpdate();
}
523
/* Low memory */
524
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
525
526
527
528
529
530
JNIEnv* env, jclass cls)
{
SDL_SendAppEvent(SDL_APP_LOWMEMORY);
}
/* Quit */
531
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
JNIEnv* env, jclass cls)
{
/* 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);
/* Resume the event loop so that the app can catch SDL_QUIT which
* should now be the top event in the event queue. */
if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);
}
/* Pause */
547
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
548
549
550
551
552
553
554
555
JNIEnv* env, jclass cls)
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");
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);
556
557
/* *After* sending the relevant events, signal the pause semaphore
558
559
560
561
562
563
* so the event loop knows to pause and (optionally) block itself */
if (!SDL_SemValue(Android_PauseSem)) SDL_SemPost(Android_PauseSem);
}
}
/* Resume */
564
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
JNIEnv* env, jclass cls)
{
__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.
*/
if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);
}
}
582
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
583
584
585
586
587
588
589
590
591
592
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendKeyboardText(utftext);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
593
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
594
595
596
597
598
599
600
601
602
603
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
SDL_SendEditingText(utftext, 0, 0);
(*env)->ReleaseStringUTFChars(env, text, utftext);
}
604
605
606
607
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
JNIEnv* env, jclass cls,
jstring name)
{
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
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;
}
/*******************************************************************************
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) {
JNIEnv* env = refholder->m_env;
(*env)->PopLocalFrame(env, NULL);
--s_active;
}
}
static SDL_bool LocalReferenceHolder_IsActive(void)
{
return s_active > 0;
}
ANativeWindow* Android_JNI_GetNativeWindow(void)
{
ANativeWindow* anw;
jobject s;
JNIEnv *env = Android_JNI_GetEnv();
s = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetNativeSurface);
anw = ANativeWindow_fromSurface(env, s);
(*env)->DeleteLocalRef(env, s);
677
678
679
680
681
682
683
return anw;
}
void Android_JNI_SetActivityTitle(const char *title)
{
JNIEnv *mEnv = Android_JNI_GetEnv();
684
685
686
687
jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));
(*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetActivityTitle, jtitle);
(*mEnv)->DeleteLocalRef(mEnv, jtitle);
688
689
}
690
691
692
void Android_JNI_SetOrientation(int w, int h, int resizable, const char *hint)
{
JNIEnv *mEnv = Android_JNI_GetEnv();
693
694
695
696
jstring jhint = (jstring)((*mEnv)->NewStringUTF(mEnv, (hint ? hint : "")));
(*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midSetOrientation, w, h, (resizable? 1 : 0), jhint);
(*mEnv)->DeleteLocalRef(mEnv, jhint);
697
698
}
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
SDL_bool Android_JNI_GetAccelerometerValues(float values[3])
{
int i;
SDL_bool retval = SDL_FALSE;
if (bHasNewData) {
for (i = 0; i < 3; ++i) {
values[i] = fLastAccelerometer[i];
}
bHasNewData = SDL_FALSE;
retval = SDL_TRUE;
}
return retval;
}
static void Android_JNI_ThreadDestroyed(void* value)
{
/* The thread is being destroyed, detach it from the Java VM and set the mThreadKey value to NULL as required */
JNIEnv *env = (JNIEnv*) value;
if (env != NULL) {
(*mJavaVM)->DetachCurrentThread(mJavaVM);
pthread_setspecific(mThreadKey, NULL);
}
}
JNIEnv* Android_JNI_GetEnv(void)
{
/* From http://developer.android.com/guide/practices/jni.html
* All threads are Linux threads, scheduled by the kernel.
* They're usually started from managed code (using Thread.start), but they can also be created elsewhere and then
* attached to the JavaVM. For example, a thread started with pthread_create can be attached with the
* JNI AttachCurrentThread or AttachCurrentThreadAsDaemon functions. Until a thread is attached, it has no JNIEnv,
* and cannot make JNI calls.
* Attaching a natively-created thread causes a java.lang.Thread object to be constructed and added to the "main"
* ThreadGroup, making it visible to the debugger. Calling AttachCurrentThread on an already-attached thread
* is a no-op.
* Note: You can call this function any number of times for the same thread, there's no harm in it
*/
JNIEnv *env;
int status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
if(status < 0) {
LOGE("failed to attach current thread");
return 0;
}
/* From http://developer.android.com/guide/practices/jni.html
* Threads attached through JNI must call DetachCurrentThread before they exit. If coding this directly is awkward,
* in Android 2.0 (Eclair) and higher you can use pthread_key_create to define a destructor function that will be
* called before the thread exits, and call DetachCurrentThread from there. (Use that key with pthread_setspecific
* to store the JNIEnv in thread-local-storage; that way it'll be passed into your destructor as the argument.)
* Note: The destructor is not called unless the stored value is != NULL
* Note: You can call this function any number of times for the same thread, there's no harm in it
* (except for some lost CPU cycles)
*/
pthread_setspecific(mThreadKey, (void*) env);
return env;
}
int Android_JNI_SetupThread(void)
{
Android_JNI_GetEnv();
return 1;
}
/*
* Audio support
*/
static jboolean audioBuffer16Bit = JNI_FALSE;
static jobject audioBuffer = NULL;
static void* audioBufferPinned = NULL;
772
773
static jboolean captureBuffer16Bit = JNI_FALSE;
static jobject captureBuffer = NULL;
774
775
int Android_JNI_OpenAudioDevice(int iscapture, int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)
776
777
778
{
jboolean audioBufferStereo;
int audioBufferFrames;
779
jobject jbufobj = NULL;
780
jboolean isCopy;
781
782
783
784
785
786
787
788
789
790
JNIEnv *env = Android_JNI_GetEnv();
if (!env) {
LOGE("callback_handler: failed to attach current thread");
}
Android_JNI_SetupThread();
audioBufferStereo = channelCount > 1;
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
if (iscapture) {
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for capture");
captureBuffer16Bit = is16Bit;
if ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureOpen, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {
/* Error during audio initialization */
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioRecord initialization!");
return 0;
}
} else {
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for output");
audioBuffer16Bit = is16Bit;
if ((*env)->CallStaticIntMethod(env, mActivityClass, midAudioOpen, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {
/* Error during audio initialization */
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioTrack initialization!");
return 0;
}
807
808
809
810
811
812
813
814
}
/* Allocating the audio buffer from the Java side and passing it as the return value for audioInit no longer works on
* Android >= 4.2 due to a "stale global reference" error. So now we allocate this buffer directly from this side. */
if (is16Bit) {
jshortArray audioBufferLocal = (*env)->NewShortArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
if (audioBufferLocal) {
815
jbufobj = (*env)->NewGlobalRef(env, audioBufferLocal);
816
817
818
819
820
821
(*env)->DeleteLocalRef(env, audioBufferLocal);
}
}
else {
jbyteArray audioBufferLocal = (*env)->NewByteArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
if (audioBufferLocal) {
822
jbufobj = (*env)->NewGlobalRef(env, audioBufferLocal);
823
824
825
826
(*env)->DeleteLocalRef(env, audioBufferLocal);
}
}
827
if (jbufobj == NULL) {
828
829
830
831
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");
return 0;
}
832
833
834
835
836
837
if (iscapture) {
captureBuffer = jbufobj;
} else {
audioBuffer = jbufobj;
}
838
isCopy = JNI_FALSE;
839
840
841
842
843
if (is16Bit) {
if (!iscapture) {
audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);
}
844
845
audioBufferFrames = (*env)->GetArrayLength(env, (jshortArray)audioBuffer);
} else {
846
847
848
if (!iscapture) {
audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);
}
849
850
audioBufferFrames = (*env)->GetArrayLength(env, (jbyteArray)audioBuffer);
}
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
if (audioBufferStereo) {
audioBufferFrames /= 2;
}
return audioBufferFrames;
}
void * Android_JNI_GetAudioBuffer(void)
{
return audioBufferPinned;
}
void Android_JNI_WriteAudioBuffer(void)
{
JNIEnv *mAudioEnv = Android_JNI_GetEnv();
if (audioBuffer16Bit) {
(*mAudioEnv)->ReleaseShortArrayElements(mAudioEnv, (jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
} else {
(*mAudioEnv)->ReleaseByteArrayElements(mAudioEnv, (jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
}
/* JNI_COMMIT means the changes are committed to the VM but the buffer remains pinned */
}
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
int Android_JNI_CaptureAudioBuffer(void *buffer, int buflen)
{
JNIEnv *env = Android_JNI_GetEnv();
jboolean isCopy = JNI_FALSE;
jint br;
if (captureBuffer16Bit) {
SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == (buflen / 2));
br = (*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_TRUE);
if (br > 0) {
jshort *ptr = (*env)->GetShortArrayElements(env, (jshortArray)captureBuffer, &isCopy);
br *= 2;
SDL_memcpy(buffer, ptr, br);
(*env)->ReleaseShortArrayElements(env, (jshortArray)captureBuffer, (jshort *)ptr, JNI_ABORT);
}
} else {
SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == buflen);
br = (*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_TRUE);
if (br > 0) {
jbyte *ptr = (*env)->GetByteArrayElements(env, (jbyteArray)captureBuffer, &isCopy);
SDL_memcpy(buffer, ptr, br);
(*env)->ReleaseByteArrayElements(env, (jbyteArray)captureBuffer, (jbyte *)ptr, JNI_ABORT);
}
}
return (int) br;
}
void Android_JNI_FlushCapturedAudio(void)
908
909
{
JNIEnv *env = Android_JNI_GetEnv();
910
#if 0 /* !!! FIXME: this needs API 23, or it'll do blocking reads and never end. */
911
912
913
914
915
916
917
if (captureBuffer16Bit) {
const jint len = (*env)->GetArrayLength(env, (jshortArray)captureBuffer);
while ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE) == len) { /* spin */ }
} else {
const jint len = (*env)->GetArrayLength(env, (jbyteArray)captureBuffer);
while ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE) == len) { /* spin */ }
}
918
#else
919
920
921
922
923
if (captureBuffer16Bit) {
(*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE);
} else {
(*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE);
}
924
#endif
925
}
926
927
928
929
void Android_JNI_CloseAudioDevice(const int iscapture)
{
JNIEnv *env = Android_JNI_GetEnv();
930
931
932
933
934
935
936
937
938
939
940
941
942
943
if (iscapture) {
(*env)->CallStaticVoidMethod(env, mActivityClass, midCaptureClose);
if (captureBuffer) {
(*env)->DeleteGlobalRef(env, captureBuffer);
captureBuffer = NULL;
}
} else {
(*env)->CallStaticVoidMethod(env, mActivityClass, midAudioClose);
if (audioBuffer) {
(*env)->DeleteGlobalRef(env, audioBuffer);
audioBuffer = NULL;
audioBufferPinned = NULL;
}
944
945
946
947
948
949
950
951
}
}
/* Test for an exception and call SDL_SetError with its detail if one occurs */
/* If the parameter silent is truthy then SDL_SetError() will not be called. */
static SDL_bool Android_JNI_ExceptionOccurred(SDL_bool silent)
{
JNIEnv *mEnv = Android_JNI_GetEnv();
952
953
954
jthrowable exception;
SDL_assert(LocalReferenceHolder_IsActive());
955
956
exception = (*mEnv)->ExceptionOccurred(mEnv);
957
958
959
960
961
962
963
964
965
if (exception != NULL) {
jmethodID mid;
/* Until this happens most JNI operations have undefined behaviour */
(*mEnv)->ExceptionClear(mEnv);
if (!silent) {
jclass exceptionClass = (*mEnv)->GetObjectClass(mEnv, exception);
jclass classClass = (*mEnv)->FindClass(mEnv, "java/lang/Class");
966
967
968
jstring exceptionName;
const char* exceptionNameUTF8;
jstring exceptionMessage;
969
970
mid = (*mEnv)->GetMethodID(mEnv, classClass, "getName", "()Ljava/lang/String;");
971
972
exceptionName = (jstring)(*mEnv)->CallObjectMethod(mEnv, exceptionClass, mid);
exceptionNameUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionName, 0);
973
974
mid = (*mEnv)->GetMethodID(mEnv, exceptionClass, "getMessage", "()Ljava/lang/String;");
975
exceptionMessage = (jstring)(*mEnv)->CallObjectMethod(mEnv, exception, mid);
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
if (exceptionMessage != NULL) {
const char* exceptionMessageUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionMessage, 0);
SDL_SetError("%s: %s", exceptionNameUTF8, exceptionMessageUTF8);
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionMessage, exceptionMessageUTF8);
} else {
SDL_SetError("%s", exceptionNameUTF8);
}
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionName, exceptionNameUTF8);
}
return SDL_TRUE;
}
return SDL_FALSE;
}
static int Internal_Android_JNI_FileOpen(SDL_RWops* ctx)
{
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
int result = 0;
jmethodID mid;