This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_android.c
1375 lines (1126 loc) · 47.8 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2013 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
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_config.h"
#include "SDL_stdinc.h"
#include "SDL_assert.h"
#include "SDL_log.h"
#ifdef __ANDROID__
#include "SDL_system.h"
#include "SDL_android.h"
30
#include <EGL/egl.h>
31
32
33
34
35
36
37
38
#include "../../events/SDL_events_c.h"
#include "../../video/android/SDL_androidkeyboard.h"
#include "../../video/android/SDL_androidtouch.h"
#include "../../video/android/SDL_androidvideo.h"
#include <android/log.h>
#include <pthread.h>
39
40
#include <sys/types.h>
#include <unistd.h>
41
42
43
44
45
46
47
48
49
50
51
#define LOG_TAG "SDL_android"
//#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 (false)
#define LOGE(...) do {} while (false)
/* Uncomment this to log messages entering and exiting methods in this file */
//#define DEBUG_JNI
/* Implemented in audio/android/SDL_androidaudio.c */
extern void Android_RunAudioThread();
52
53
static void Android_JNI_ThreadDestroyed(void*);
54
55
56
57
58
59
/*******************************************************************************
This file links the Java side of Android with libsdl
*******************************************************************************/
#include <jni.h>
#include <android/log.h>
60
#include <stdbool.h>
61
62
63
64
65
66
67
68
69
70
71
72
73
/*******************************************************************************
Globals
*******************************************************************************/
static pthread_key_t mThreadKey;
static JavaVM* mJavaVM;
// Main activity
static jclass mActivityClass;
// method signatures
static jmethodID midCreateGLContext;
74
static jmethodID midDeleteGLContext;
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
static jmethodID midFlipBuffers;
static jmethodID midAudioInit;
static jmethodID midAudioWriteShortBuffer;
static jmethodID midAudioWriteByteBuffer;
static jmethodID midAudioQuit;
// Accelerometer data storage
static float fLastAccelerometer[3];
static bool bHasNewData;
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
// Library init
90
jint JNI_OnLoad(JavaVM* vm, void* reserved)
91
92
93
94
{
JNIEnv *env;
mJavaVM = vm;
LOGI("JNI_OnLoad called");
95
if ((*mJavaVM)->GetEnv(mJavaVM, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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)) {
__android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing pthread key");
}
else {
Android_JNI_SetupThread();
}
return JNI_VERSION_1_4;
}
// Called before SDL_main() to initialize JNI bindings
114
void SDL_Android_Init(JNIEnv* mEnv, jclass cls)
115
116
117
118
119
{
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init()");
Android_JNI_SetupThread();
120
mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
121
122
midCreateGLContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
123
"createGLContext","(II[I)Z");
124
125
midDeleteGLContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
"deleteGLContext","()V");
126
midFlipBuffers = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
127
"flipBuffers","()V");
128
midAudioInit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
129
"audioInit", "(IZZI)I");
130
midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
131
"audioWriteShortBuffer", "([S)V");
132
midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
133
"audioWriteByteBuffer", "([B)V");
134
midAudioQuit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
135
136
137
138
139
140
141
142
143
144
145
146
"audioQuit", "()V");
bHasNewData = false;
if(!midCreateGLContext || !midFlipBuffers || !midAudioInit ||
!midAudioWriteShortBuffer || !midAudioWriteByteBuffer || !midAudioQuit) {
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java callbacks, check that they're named and typed correctly");
}
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init() finished!");
}
// Resize
147
void Java_org_libsdl_app_SDLActivity_onNativeResize(
148
149
150
151
152
153
154
JNIEnv* env, jclass jcls,
jint width, jint height, jint format)
{
Android_SetScreenResolution(width, height, format);
}
// Keydown
155
void Java_org_libsdl_app_SDLActivity_onNativeKeyDown(
156
157
158
159
160
161
JNIEnv* env, jclass jcls, jint keycode)
{
Android_OnKeyDown(keycode);
}
// Keyup
162
void Java_org_libsdl_app_SDLActivity_onNativeKeyUp(
163
164
165
166
167
JNIEnv* env, jclass jcls, jint keycode)
{
Android_OnKeyUp(keycode);
}
168
169
170
171
172
173
174
175
176
// Keyboard Focus Lost
void Java_org_libsdl_app_SDLActivity_onNativeKeyboardFocusLost(
JNIEnv* env, jclass jcls)
{
/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
SDL_StopTextInput();
}
177
// Touch
178
void Java_org_libsdl_app_SDLActivity_onNativeTouch(
179
180
181
182
183
184
185
186
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);
}
// Accelerometer
187
void Java_org_libsdl_app_SDLActivity_onNativeAccel(
188
189
190
191
192
193
194
195
196
JNIEnv* env, jclass jcls,
jfloat x, jfloat y, jfloat z)
{
fLastAccelerometer[0] = x;
fLastAccelerometer[1] = y;
fLastAccelerometer[2] = z;
bHasNewData = true;
}
197
// Low memory
198
void Java_org_libsdl_app_SDLActivity_nativeLowMemory(
199
JNIEnv* env, jclass cls)
200
{
201
202
203
SDL_SendAppEvent(SDL_APP_LOWMEMORY);
}
204
// Quit
205
void Java_org_libsdl_app_SDLActivity_nativeQuit(
206
JNIEnv* env, jclass cls)
207
{
208
209
// Inject a SDL_QUIT event
SDL_SendQuit();
210
SDL_SendAppEvent(SDL_APP_TERMINATING);
211
212
213
}
// Pause
214
void Java_org_libsdl_app_SDLActivity_nativePause(
215
216
217
218
219
220
221
222
JNIEnv* env, jclass cls)
{
if (Android_Window) {
/* Signal the pause semaphore so the event loop knows to pause and (optionally) block itself */
if (!SDL_SemValue(Android_PauseSem)) SDL_SemPost(Android_PauseSem);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
}
223
224
225
226
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");
SDL_SendAppEvent(SDL_APP_WILLENTERBACKGROUND);
SDL_SendAppEvent(SDL_APP_DIDENTERBACKGROUND);
227
228
229
}
// Resume
230
void Java_org_libsdl_app_SDLActivity_nativeResume(
231
232
JNIEnv* env, jclass cls)
{
233
234
235
236
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeResume()");
SDL_SendAppEvent(SDL_APP_WILLENTERFOREGROUND);
SDL_SendAppEvent(SDL_APP_DIDENTERFOREGROUND);
237
238
239
240
241
242
243
244
245
246
247
if (Android_Window) {
/* 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);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESTORED, 0, 0);
}
}
248
void Java_org_libsdl_app_SDLActivity_nativeRunAudioThread(
249
250
251
252
253
254
255
256
JNIEnv* env, jclass cls)
{
/* This is the audio thread, with a different environment */
Android_JNI_SetupThread();
Android_RunAudioThread();
}
257
void Java_org_libsdl_app_SDLInputConnection_nativeCommitText(
258
259
260
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition)
{
261
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
262
263
264
SDL_SendKeyboardText(utftext);
265
(*env)->ReleaseStringUTFChars(env, text, utftext);
266
267
}
268
void Java_org_libsdl_app_SDLInputConnection_nativeSetComposingText(
269
270
271
JNIEnv* env, jclass cls,
jstring text, jint newCursorPosition)
{
272
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
273
274
275
SDL_SendEditingText(utftext, 0, 0);
276
(*env)->ReleaseStringUTFChars(env, text, utftext);
277
278
279
280
281
282
283
284
}
/*******************************************************************************
Functions called by SDL into Java
*******************************************************************************/
285
286
static int s_active = 0;
struct LocalReferenceHolder
287
{
288
289
290
JNIEnv *m_env;
const char *m_func;
};
291
292
293
294
295
296
static struct LocalReferenceHolder LocalReferenceHolder_Setup(const char *func)
{
struct LocalReferenceHolder refholder;
refholder.m_env = NULL;
refholder.m_func = func;
297
#ifdef DEBUG_JNI
298
SDL_Log("Entering function %s", func);
299
#endif
300
301
302
303
304
305
306
307
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");
308
return SDL_FALSE;
309
}
310
311
312
313
314
315
316
++s_active;
refholder->m_env = env;
return SDL_TRUE;
}
static void LocalReferenceHolder_Cleanup(struct LocalReferenceHolder *refholder)
{
317
#ifdef DEBUG_JNI
318
SDL_Log("Leaving function %s", refholder->m_func);
319
#endif
320
321
322
323
if (refholder->m_env) {
JNIEnv* env = refholder->m_env;
(*env)->PopLocalFrame(env, NULL);
--s_active;
324
}
325
}
326
327
328
329
330
static SDL_bool LocalReferenceHolder_IsActive()
{
return s_active > 0;
}
331
332
333
SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion,
334
335
336
int red, int green, int blue, int alpha,
int buffer, int depth, int stencil,
int buffers, int samples)
337
{
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
JNIEnv *env = Android_JNI_GetEnv();
jint attribs[] = {
EGL_RED_SIZE, red,
EGL_GREEN_SIZE, green,
EGL_BLUE_SIZE, blue,
EGL_ALPHA_SIZE, alpha,
EGL_BUFFER_SIZE, buffer,
EGL_DEPTH_SIZE, depth,
EGL_STENCIL_SIZE, stencil,
EGL_SAMPLE_BUFFERS, buffers,
EGL_SAMPLES, samples,
EGL_RENDERABLE_TYPE, (majorVersion == 1 ? EGL_OPENGL_ES_BIT : EGL_OPENGL_ES2_BIT),
EGL_NONE
};
int len = SDL_arraysize(attribs);
jintArray array;
357
358
array = (*env)->NewIntArray(env, len);
(*env)->SetIntArrayRegion(env, array, 0, len, attribs);
359
360
jboolean success = (*env)->CallStaticBooleanMethod(env, mActivityClass, midCreateGLContext, majorVersion, minorVersion, array);
361
362
(*env)->DeleteLocalRef(env, array);
363
364
return success ? SDL_TRUE : SDL_FALSE;
365
366
}
367
368
369
370
SDL_bool Android_JNI_DeleteContext(SDL_GLContext context)
{
/* There's only one context, so the parameter is ignored for now */
JNIEnv *env = Android_JNI_GetEnv();
371
(*env)->CallStaticVoidMethod(env, mActivityClass, midDeleteGLContext);
372
373
}
374
void Android_JNI_SwapWindow()
375
376
{
JNIEnv *mEnv = Android_JNI_GetEnv();
377
(*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midFlipBuffers);
378
379
}
380
void Android_JNI_SetActivityTitle(const char *title)
381
382
383
{
jmethodID mid;
JNIEnv *mEnv = Android_JNI_GetEnv();
384
mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,"setActivityTitle","(Ljava/lang/String;)Z");
385
if (mid) {
386
387
388
jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));
(*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, mid, jtitle);
(*mEnv)->DeleteLocalRef(mEnv, jtitle);
389
390
391
}
}
392
SDL_bool Android_JNI_GetAccelerometerValues(float values[3])
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
{
int i;
SDL_bool retval = SDL_FALSE;
if (bHasNewData) {
for (i = 0; i < 3; ++i) {
values[i] = fLastAccelerometer[i];
}
bHasNewData = 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) {
412
(*mJavaVM)->DetachCurrentThread(mJavaVM);
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
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;
431
int status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
if(status < 0) {
LOGE("failed to attach current thread");
return 0;
}
return env;
}
int Android_JNI_SetupThread(void) {
/* 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)
*/
JNIEnv *env = Android_JNI_GetEnv();
pthread_setspecific(mThreadKey, (void*) env);
return 1;
}
//
// Audio support
//
static jboolean audioBuffer16Bit = JNI_FALSE;
static jboolean audioBufferStereo = JNI_FALSE;
static jobject audioBuffer = NULL;
static void* audioBufferPinned = NULL;
463
int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)
464
465
466
467
468
469
470
471
472
473
474
475
476
477
{
int audioBufferFrames;
JNIEnv *env = Android_JNI_GetEnv();
if (!env) {
LOGE("callback_handler: failed to attach current thread");
}
Android_JNI_SetupThread();
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device");
audioBuffer16Bit = is16Bit;
audioBufferStereo = channelCount > 1;
478
479
480
481
482
if ((*env)->CallStaticIntMethod(env, mActivityClass, midAudioInit, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {
/* Error during audio initialization */
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioTrack initialization!");
return 0;
}
483
484
485
/* 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. */
486
487
if (is16Bit) {
488
jshortArray audioBufferLocal = (*env)->NewShortArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
489
if (audioBufferLocal) {
490
491
audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
(*env)->DeleteLocalRef(env, audioBufferLocal);
492
493
494
}
}
else {
495
jbyteArray audioBufferLocal = (*env)->NewByteArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
496
if (audioBufferLocal) {
497
498
audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
(*env)->DeleteLocalRef(env, audioBufferLocal);
499
500
}
}
501
502
if (audioBuffer == NULL) {
503
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");
504
505
506
507
508
return 0;
}
jboolean isCopy = JNI_FALSE;
if (audioBuffer16Bit) {
509
510
audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);
audioBufferFrames = (*env)->GetArrayLength(env, (jshortArray)audioBuffer);
511
} else {
512
513
audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);
audioBufferFrames = (*env)->GetArrayLength(env, (jbyteArray)audioBuffer);
514
515
516
517
}
if (audioBufferStereo) {
audioBufferFrames /= 2;
}
518
519
520
521
return audioBufferFrames;
}
522
void * Android_JNI_GetAudioBuffer()
523
524
525
526
{
return audioBufferPinned;
}
527
void Android_JNI_WriteAudioBuffer()
528
529
530
531
{
JNIEnv *mAudioEnv = Android_JNI_GetEnv();
if (audioBuffer16Bit) {
532
533
(*mAudioEnv)->ReleaseShortArrayElements(mAudioEnv, (jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
534
} else {
535
536
(*mAudioEnv)->ReleaseByteArrayElements(mAudioEnv, (jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
537
538
539
540
541
}
/* JNI_COMMIT means the changes are committed to the VM but the buffer remains pinned */
}
542
void Android_JNI_CloseAudioDevice()
543
544
545
{
JNIEnv *env = Android_JNI_GetEnv();
546
(*env)->CallStaticVoidMethod(env, mActivityClass, midAudioQuit);
547
548
if (audioBuffer) {
549
(*env)->DeleteGlobalRef(env, audioBuffer);
550
551
552
553
554
555
audioBuffer = NULL;
audioBufferPinned = NULL;
}
}
// Test for an exception and call SDL_SetError with its detail if one occurs
556
// If the parameter silent is truthy then SDL_SetError() will not be called.
557
static bool Android_JNI_ExceptionOccurred(bool silent)
558
{
559
SDL_assert(LocalReferenceHolder_IsActive());
560
561
JNIEnv *mEnv = Android_JNI_GetEnv();
562
jthrowable exception = (*mEnv)->ExceptionOccurred(mEnv);
563
564
565
566
if (exception != NULL) {
jmethodID mid;
// Until this happens most JNI operations have undefined behaviour
567
(*mEnv)->ExceptionClear(mEnv);
568
569
if (!silent) {
570
571
jclass exceptionClass = (*mEnv)->GetObjectClass(mEnv, exception);
jclass classClass = (*mEnv)->FindClass(mEnv, "java/lang/Class");
572
573
574
575
mid = (*mEnv)->GetMethodID(mEnv, classClass, "getName", "()Ljava/lang/String;");
jstring exceptionName = (jstring)(*mEnv)->CallObjectMethod(mEnv, exceptionClass, mid);
const char* exceptionNameUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionName, 0);
576
577
578
mid = (*mEnv)->GetMethodID(mEnv, exceptionClass, "getMessage", "()Ljava/lang/String;");
jstring exceptionMessage = (jstring)(*mEnv)->CallObjectMethod(mEnv, exception, mid);
579
580
if (exceptionMessage != NULL) {
581
const char* exceptionMessageUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionMessage, 0);
582
SDL_SetError("%s: %s", exceptionNameUTF8, exceptionMessageUTF8);
583
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionMessage, exceptionMessageUTF8);
584
585
586
} else {
SDL_SetError("%s", exceptionNameUTF8);
}
587
588
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionName, exceptionNameUTF8);
589
}
590
591
592
593
594
595
596
return true;
}
return false;
}
597
static int Internal_Android_JNI_FileOpen(SDL_RWops* ctx)
598
{
599
600
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
601
602
603
604
605
606
607
608
609
int result = 0;
jmethodID mid;
jobject context;
jobject assetManager;
jobject inputStream;
jclass channels;
jobject readableByteChannel;
jstring fileNameJString;
610
611
612
jobject fd;
jclass fdCls;
jfieldID descriptor;
613
614
JNIEnv *mEnv = Android_JNI_GetEnv();
615
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
616
617
618
619
goto failure;
}
fileNameJString = (jstring)ctx->hidden.androidio.fileNameRef;
620
ctx->hidden.androidio.position = 0;
621
622
// context = SDLActivity.getContext();
623
mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
624
"getContext","()Landroid/content/Context;");
625
context = (*mEnv)->CallStaticObjectMethod(mEnv, mActivityClass, mid);
626
627
628
// assetManager = context.getAssets();
629
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, context),
630
"getAssets", "()Landroid/content/res/AssetManager;");
631
assetManager = (*mEnv)->CallObjectMethod(mEnv, context, mid);
632
633
634
635
/* First let's try opening the file to obtain an AssetFileDescriptor.
* This method reads the files directly from the APKs using standard *nix calls
*/
636
637
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, assetManager), "openFd", "(Ljava/lang/String;)Landroid/content/res/AssetFileDescriptor;");
inputStream = (*mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString);
638
if (Android_JNI_ExceptionOccurred(true)) {
639
goto fallback;
640
641
}
642
643
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream), "getStartOffset", "()J");
ctx->hidden.androidio.offset = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
644
if (Android_JNI_ExceptionOccurred(true)) {
645
goto fallback;
646
647
}
648
649
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream), "getDeclaredLength", "()J");
ctx->hidden.androidio.size = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
650
if (Android_JNI_ExceptionOccurred(true)) {
651
goto fallback;
652
653
}
654
655
656
657
658
659
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream), "getFileDescriptor", "()Ljava/io/FileDescriptor;");
fd = (*mEnv)->CallObjectMethod(mEnv, inputStream, mid);
fdCls = (*mEnv)->GetObjectClass(mEnv, fd);
descriptor = (*mEnv)->GetFieldID(mEnv, fdCls, "descriptor", "I");
ctx->hidden.androidio.fd = (*mEnv)->GetIntField(mEnv, fd, descriptor);
ctx->hidden.androidio.assetFileDescriptorRef = (*mEnv)->NewGlobalRef(mEnv, inputStream);
660
661
662
663
// Seek to the correct offset in the file.
lseek(ctx->hidden.androidio.fd, (off_t)ctx->hidden.androidio.offset, SEEK_SET);
664
665
if (false) {
fallback:
666
667
668
// Disabled log message because of spam on the Nexus 7
//__android_log_print(ANDROID_LOG_DEBUG, "SDL", "Falling back to legacy InputStream method for opening file");
669
670
671
672
/* Try the old method using InputStream */
ctx->hidden.androidio.assetFileDescriptorRef = NULL;
// inputStream = assetManager.open(<filename>);
673
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, assetManager),
674
"open", "(Ljava/lang/String;I)Ljava/io/InputStream;");
675
676
inputStream = (*mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString, 1 /*ACCESS_RANDOM*/);
if (Android_JNI_ExceptionOccurred(false)) {
677
678
goto failure;
}
679
680
ctx->hidden.androidio.inputStreamRef = (*mEnv)->NewGlobalRef(mEnv, inputStream);
681
682
683
684
685
686
687
688
// Despite all the visible documentation on [Asset]InputStream claiming
// that the .available() method is not guaranteed to return the entire file
// size, comments in <sdk>/samples/<ver>/ApiDemos/src/com/example/ ...
// android/apis/content/ReadAsset.java imply that Android's
// AssetInputStream.available() /will/ always return the total file size
// size = inputStream.available();
689
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
690
"available", "()I");
691
692
ctx->hidden.androidio.size = (long)(*mEnv)->CallIntMethod(mEnv, inputStream, mid);
if (Android_JNI_ExceptionOccurred(false)) {
693
694
695
696
goto failure;
}
// readableByteChannel = Channels.newChannel(inputStream);
697
698
channels = (*mEnv)->FindClass(mEnv, "java/nio/channels/Channels");
mid = (*mEnv)->GetStaticMethodID(mEnv, channels,
699
700
"newChannel",
"(Ljava/io/InputStream;)Ljava/nio/channels/ReadableByteChannel;");
701
702
703
readableByteChannel = (*mEnv)->CallStaticObjectMethod(
mEnv, channels, mid, inputStream);
if (Android_JNI_ExceptionOccurred(false)) {
704
705
706
707
goto failure;
}
ctx->hidden.androidio.readableByteChannelRef =
708
(*mEnv)->NewGlobalRef(mEnv, readableByteChannel);
709
710
// Store .read id for reading purposes
711
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, readableByteChannel),
712
713
714
"read", "(Ljava/nio/ByteBuffer;)I");
ctx->hidden.androidio.readMethod = mid;
}
715
716
717
718
719
if (false) {
failure:
result = -1;
720
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
721
722
if(ctx->hidden.androidio.inputStreamRef != NULL) {
723
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.inputStreamRef);
724
725
726
}
if(ctx->hidden.androidio.readableByteChannelRef != NULL) {
727
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.readableByteChannelRef);
728
729
}
730
if(ctx->hidden.androidio.assetFileDescriptorRef != NULL) {
731
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
732
733
}
734
}
735
736
LocalReferenceHolder_Cleanup(&refs);
737
738
739
return result;
}
740
741
int Android_JNI_FileOpen(SDL_RWops* ctx,
const char* fileName, const char* mode)
742
{
743
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
744
JNIEnv *mEnv = Android_JNI_GetEnv();
745
int retval;
746
747
748
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
749
750
751
752
return -1;
}
if (!ctx) {
753
LocalReferenceHolder_Cleanup(&refs);
754
755
756
return -1;
}
757
758
jstring fileNameJString = (*mEnv)->NewStringUTF(mEnv, fileName);
ctx->hidden.androidio.fileNameRef = (*mEnv)->NewGlobalRef(mEnv, fileNameJString);
759
760
761
ctx->hidden.androidio.inputStreamRef = NULL;
ctx->hidden.androidio.readableByteChannelRef = NULL;
ctx->hidden.androidio.readMethod = NULL;
762
ctx->hidden.androidio.assetFileDescriptorRef = NULL;
763
764
765
766
retval = Internal_Android_JNI_FileOpen(ctx);
LocalReferenceHolder_Cleanup(&refs);
return retval;
767
768
}
769
size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,
770
771
size_t size, size_t maxnum)
{
772
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
773
774
775
776
777
778
779
780
781
if (ctx->hidden.androidio.assetFileDescriptorRef) {
size_t bytesMax = size * maxnum;
if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && ctx->hidden.androidio.position + bytesMax > ctx->hidden.androidio.size) {
bytesMax = ctx->hidden.androidio.size - ctx->hidden.androidio.position;
}
size_t result = read(ctx->hidden.androidio.fd, buffer, bytesMax );
if (result > 0) {
ctx->hidden.androidio.position += result;
782
LocalReferenceHolder_Cleanup(&refs);
783
784
return result / size;
}
785
LocalReferenceHolder_Cleanup(&refs);
786
787
788
789
790
return 0;
} else {
jlong bytesRemaining = (jlong) (size * maxnum);
jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
int bytesRead = 0;
791
792
793
/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;
794
795
JNIEnv *mEnv = Android_JNI_GetEnv();
796
797
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
798
return 0;
799
}
800
801
802
jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
803
jobject byteBuffer = (*mEnv)->NewDirectByteBuffer(mEnv, buffer, bytesRemaining);
804
805
806
while (bytesRemaining > 0) {
// result = readableByteChannel.read(...);
807
int result = (*mEnv)->CallIntMethod(mEnv, readableByteChannel, readMethod, byteBuffer);
808
809
810
if (Android_JNI_ExceptionOccurred(false)) {
LocalReferenceHolder_Cleanup(&refs);
811
812
return 0;
}
813
814
815
816
if (result < 0) {
break;
}
817
818
819
820
821
bytesRemaining -= result;
bytesRead += result;
ctx->hidden.androidio.position += result;
}
822
LocalReferenceHolder_Cleanup(&refs);
823
return bytesRead / size;
824
}
825
826
}
827
size_t Android_JNI_FileWrite(SDL_RWops* ctx, const void* buffer,
828
829
830
831
832
833
size_t size, size_t num)
{
SDL_SetError("Cannot write to Android package filesystem");
return 0;
}
834
static int Internal_Android_JNI_FileClose(SDL_RWops* ctx, bool release)
835
{
836
837
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
838
839
840
int result = 0;
JNIEnv *mEnv = Android_JNI_GetEnv();
841
842
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
843
return SDL_SetError("Failed to allocate enough JVM local references");
844
845
846
847
}
if (ctx) {
if (release) {
848
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
849
850
}
851
852
if (ctx->hidden.androidio.assetFileDescriptorRef) {
jobject inputStream = (jobject)ctx->hidden.androidio.assetFileDescriptorRef;
853
jmethodID mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
854
"close", "()V");
855
856
857
(*mEnv)->CallVoidMethod(mEnv, inputStream, mid);
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
if (Android_JNI_ExceptionOccurred(false)) {
858
859
860
861
862
result = -1;
}
}
else {
jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;
863
864
// inputStream.close();
865
jmethodID mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
866
"close", "()V");
867
868
869
870
(*mEnv)->CallVoidMethod(mEnv, inputStream, mid);
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.inputStreamRef);
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.readableByteChannelRef);
if (Android_JNI_ExceptionOccurred(false)) {
871
872
result = -1;
}
873
874
875
876
877
878
879
}
if (release) {
SDL_FreeRW(ctx);
}
}
880
LocalReferenceHolder_Cleanup(&refs);
881
882
883
884
return result;
}
885
Sint64 Android_JNI_FileSize(SDL_RWops* ctx)
886
887
888
889
{
return ctx->hidden.androidio.size;
}
890
Sint64 Android_JNI_FileSeek(SDL_RWops* ctx, Sint64 offset, int whence)
891
{
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
if (ctx->hidden.androidio.assetFileDescriptorRef) {
switch (whence) {
case RW_SEEK_SET:
if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && offset > ctx->hidden.androidio.size) offset = ctx->hidden.androidio.size;
offset += ctx->hidden.androidio.offset;
break;
case RW_SEEK_CUR:
offset += ctx->hidden.androidio.position;
if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && offset > ctx->hidden.androidio.size) offset = ctx->hidden.androidio.size;
offset += ctx->hidden.androidio.offset;
break;
case RW_SEEK_END:
offset = ctx->hidden.androidio.offset + ctx->hidden.androidio.size + offset;
break;
default:
907
return SDL_SetError("Unknown value for 'whence'");
908
909
}
whence = SEEK_SET;
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
off_t ret = lseek(ctx->hidden.androidio.fd, (off_t)offset, SEEK_SET);
if (ret == -1) return -1;
ctx->hidden.androidio.position = ret - ctx->hidden.androidio.offset;
} else {
Sint64 newPosition;
switch (whence) {
case RW_SEEK_SET:
newPosition = offset;
break;
case RW_SEEK_CUR:
newPosition = ctx->hidden.androidio.position + offset;
break;
case RW_SEEK_END:
newPosition = ctx->hidden.androidio.size + offset;
break;
default:
928
return SDL_SetError("Unknown value for 'whence'");
929
}
930
931
932
/* Validate the new position */
if (newPosition < 0) {
933
return SDL_Error(SDL_EFSEEK);
934
935
936
937
}
if (newPosition > ctx->hidden.androidio.size) {
newPosition = ctx->hidden.androidio.size;
}
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
Sint64 movement = newPosition - ctx->hidden.androidio.position;
if (movement > 0) {
unsigned char buffer[4096];
// The easy case where we're seeking forwards
while (movement > 0) {
Sint64 amount = sizeof (buffer);
if (amount > movement) {
amount = movement;
}
size_t result = Android_JNI_FileRead(ctx, buffer, 1, amount);
if (result <= 0) {
// Failed to read/skip the required amount, so fail
return -1;
}
movement -= result;
956
957
}
958
959
960
} else if (movement < 0) {
// We can't seek backwards so we have to reopen the file and seek
// forwards which obviously isn't very efficient
961
962
Internal_Android_JNI_FileClose(ctx, false);
Internal_Android_JNI_FileOpen(ctx);
963
Android_JNI_FileSeek(ctx, newPosition, RW_SEEK_SET);
964
965
966
967
}
}
return ctx->hidden.androidio.position;
968
969
970
}
971
int Android_JNI_FileClose(SDL_RWops* ctx)
972
{
973
return Internal_Android_JNI_FileClose(ctx, true);
974
975
976
977
978
}
// returns a new global reference which needs to be released later
static jobject Android_JNI_GetSystemServiceObject(const char* name)
{
979
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
980
JNIEnv* env = Android_JNI_GetEnv();
981
982
983
984
jobject retval = NULL;
if (!LocalReferenceHolder_Init(&refs, env)) {
LocalReferenceHolder_Cleanup(&refs);
985
986
987
return NULL;
}
988
jstring service = (*env)->NewStringUTF(env, name);
989
990
991
jmethodID mid;
992
993
mid = (*env)->GetStaticMethodID(env, mActivityClass, "getContext", "()Landroid/content/Context;");
jobject context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
994
995
996
mid = (*env)->GetMethodID(env, mActivityClass, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jobject manager = (*env)->CallObjectMethod(env, context, mid, service);
997
998
(*env)->DeleteLocalRef(env, service);
999
1000
retval = manager ? (*env)->NewGlobalRef(env, manager) : NULL;