This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_android.c
1376 lines (1127 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
return SDL_TRUE;
373
374
}
375
void Android_JNI_SwapWindow()
376
377
{
JNIEnv *mEnv = Android_JNI_GetEnv();
378
(*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midFlipBuffers);
379
380
}
381
void Android_JNI_SetActivityTitle(const char *title)
382
383
384
{
jmethodID mid;
JNIEnv *mEnv = Android_JNI_GetEnv();
385
mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,"setActivityTitle","(Ljava/lang/String;)Z");
386
if (mid) {
387
388
389
jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));
(*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, mid, jtitle);
(*mEnv)->DeleteLocalRef(mEnv, jtitle);
390
391
392
}
}
393
SDL_bool Android_JNI_GetAccelerometerValues(float values[3])
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
{
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) {
413
(*mJavaVM)->DetachCurrentThread(mJavaVM);
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
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;
432
int status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
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
463
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;
464
int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)
465
466
467
468
469
470
471
472
473
474
475
476
477
478
{
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;
479
480
481
482
483
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;
}
484
485
486
/* 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. */
487
488
if (is16Bit) {
489
jshortArray audioBufferLocal = (*env)->NewShortArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
490
if (audioBufferLocal) {
491
492
audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
(*env)->DeleteLocalRef(env, audioBufferLocal);
493
494
495
}
}
else {
496
jbyteArray audioBufferLocal = (*env)->NewByteArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));
497
if (audioBufferLocal) {
498
499
audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
(*env)->DeleteLocalRef(env, audioBufferLocal);
500
501
}
}
502
503
if (audioBuffer == NULL) {
504
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");
505
506
507
508
509
return 0;
}
jboolean isCopy = JNI_FALSE;
if (audioBuffer16Bit) {
510
511
audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);
audioBufferFrames = (*env)->GetArrayLength(env, (jshortArray)audioBuffer);
512
} else {
513
514
audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);
audioBufferFrames = (*env)->GetArrayLength(env, (jbyteArray)audioBuffer);
515
516
517
518
}
if (audioBufferStereo) {
audioBufferFrames /= 2;
}
519
520
521
522
return audioBufferFrames;
}
523
void * Android_JNI_GetAudioBuffer()
524
525
526
527
{
return audioBufferPinned;
}
528
void Android_JNI_WriteAudioBuffer()
529
530
531
532
{
JNIEnv *mAudioEnv = Android_JNI_GetEnv();
if (audioBuffer16Bit) {
533
534
(*mAudioEnv)->ReleaseShortArrayElements(mAudioEnv, (jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
535
} else {
536
537
(*mAudioEnv)->ReleaseByteArrayElements(mAudioEnv, (jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);
(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
538
539
540
541
542
}
/* JNI_COMMIT means the changes are committed to the VM but the buffer remains pinned */
}
543
void Android_JNI_CloseAudioDevice()
544
545
546
{
JNIEnv *env = Android_JNI_GetEnv();
547
(*env)->CallStaticVoidMethod(env, mActivityClass, midAudioQuit);
548
549
if (audioBuffer) {
550
(*env)->DeleteGlobalRef(env, audioBuffer);
551
552
553
554
555
556
audioBuffer = NULL;
audioBufferPinned = NULL;
}
}
// Test for an exception and call SDL_SetError with its detail if one occurs
557
// If the parameter silent is truthy then SDL_SetError() will not be called.
558
static bool Android_JNI_ExceptionOccurred(bool silent)
559
{
560
SDL_assert(LocalReferenceHolder_IsActive());
561
562
JNIEnv *mEnv = Android_JNI_GetEnv();
563
jthrowable exception = (*mEnv)->ExceptionOccurred(mEnv);
564
565
566
567
if (exception != NULL) {
jmethodID mid;
// Until this happens most JNI operations have undefined behaviour
568
(*mEnv)->ExceptionClear(mEnv);
569
570
if (!silent) {
571
572
jclass exceptionClass = (*mEnv)->GetObjectClass(mEnv, exception);
jclass classClass = (*mEnv)->FindClass(mEnv, "java/lang/Class");
573
574
575
576
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);
577
578
579
mid = (*mEnv)->GetMethodID(mEnv, exceptionClass, "getMessage", "()Ljava/lang/String;");
jstring exceptionMessage = (jstring)(*mEnv)->CallObjectMethod(mEnv, exception, mid);
580
581
if (exceptionMessage != NULL) {
582
const char* exceptionMessageUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionMessage, 0);
583
SDL_SetError("%s: %s", exceptionNameUTF8, exceptionMessageUTF8);
584
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionMessage, exceptionMessageUTF8);
585
586
587
} else {
SDL_SetError("%s", exceptionNameUTF8);
}
588
589
(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionName, exceptionNameUTF8);
590
}
591
592
593
594
595
596
597
return true;
}
return false;
}
598
static int Internal_Android_JNI_FileOpen(SDL_RWops* ctx)
599
{
600
601
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
602
603
604
605
606
607
608
609
610
int result = 0;
jmethodID mid;
jobject context;
jobject assetManager;
jobject inputStream;
jclass channels;
jobject readableByteChannel;
jstring fileNameJString;
611
612
613
jobject fd;
jclass fdCls;
jfieldID descriptor;
614
615
JNIEnv *mEnv = Android_JNI_GetEnv();
616
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
617
618
619
620
goto failure;
}
fileNameJString = (jstring)ctx->hidden.androidio.fileNameRef;
621
ctx->hidden.androidio.position = 0;
622
623
// context = SDLActivity.getContext();
624
mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
625
"getContext","()Landroid/content/Context;");
626
context = (*mEnv)->CallStaticObjectMethod(mEnv, mActivityClass, mid);
627
628
629
// assetManager = context.getAssets();
630
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, context),
631
"getAssets", "()Landroid/content/res/AssetManager;");
632
assetManager = (*mEnv)->CallObjectMethod(mEnv, context, mid);
633
634
635
636
/* First let's try opening the file to obtain an AssetFileDescriptor.
* This method reads the files directly from the APKs using standard *nix calls
*/
637
638
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, assetManager), "openFd", "(Ljava/lang/String;)Landroid/content/res/AssetFileDescriptor;");
inputStream = (*mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString);
639
if (Android_JNI_ExceptionOccurred(true)) {
640
goto fallback;
641
642
}
643
644
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream), "getStartOffset", "()J");
ctx->hidden.androidio.offset = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
645
if (Android_JNI_ExceptionOccurred(true)) {
646
goto fallback;
647
648
}
649
650
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream), "getDeclaredLength", "()J");
ctx->hidden.androidio.size = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
651
if (Android_JNI_ExceptionOccurred(true)) {
652
goto fallback;
653
654
}
655
656
657
658
659
660
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);
661
662
663
664
// Seek to the correct offset in the file.
lseek(ctx->hidden.androidio.fd, (off_t)ctx->hidden.androidio.offset, SEEK_SET);
665
666
if (false) {
fallback:
667
668
669
// 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");
670
671
672
673
/* Try the old method using InputStream */
ctx->hidden.androidio.assetFileDescriptorRef = NULL;
// inputStream = assetManager.open(<filename>);
674
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, assetManager),
675
"open", "(Ljava/lang/String;I)Ljava/io/InputStream;");
676
677
inputStream = (*mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString, 1 /*ACCESS_RANDOM*/);
if (Android_JNI_ExceptionOccurred(false)) {
678
679
goto failure;
}
680
681
ctx->hidden.androidio.inputStreamRef = (*mEnv)->NewGlobalRef(mEnv, inputStream);
682
683
684
685
686
687
688
689
// 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();
690
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
691
"available", "()I");
692
693
ctx->hidden.androidio.size = (long)(*mEnv)->CallIntMethod(mEnv, inputStream, mid);
if (Android_JNI_ExceptionOccurred(false)) {
694
695
696
697
goto failure;
}
// readableByteChannel = Channels.newChannel(inputStream);
698
699
channels = (*mEnv)->FindClass(mEnv, "java/nio/channels/Channels");
mid = (*mEnv)->GetStaticMethodID(mEnv, channels,
700
701
"newChannel",
"(Ljava/io/InputStream;)Ljava/nio/channels/ReadableByteChannel;");
702
703
704
readableByteChannel = (*mEnv)->CallStaticObjectMethod(
mEnv, channels, mid, inputStream);
if (Android_JNI_ExceptionOccurred(false)) {
705
706
707
708
goto failure;
}
ctx->hidden.androidio.readableByteChannelRef =
709
(*mEnv)->NewGlobalRef(mEnv, readableByteChannel);
710
711
// Store .read id for reading purposes
712
mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, readableByteChannel),
713
714
715
"read", "(Ljava/nio/ByteBuffer;)I");
ctx->hidden.androidio.readMethod = mid;
}
716
717
718
719
720
if (false) {
failure:
result = -1;
721
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
722
723
if(ctx->hidden.androidio.inputStreamRef != NULL) {
724
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.inputStreamRef);
725
726
727
}
if(ctx->hidden.androidio.readableByteChannelRef != NULL) {
728
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.readableByteChannelRef);
729
730
}
731
if(ctx->hidden.androidio.assetFileDescriptorRef != NULL) {
732
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
733
734
}
735
}
736
737
LocalReferenceHolder_Cleanup(&refs);
738
739
740
return result;
}
741
742
int Android_JNI_FileOpen(SDL_RWops* ctx,
const char* fileName, const char* mode)
743
{
744
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
745
JNIEnv *mEnv = Android_JNI_GetEnv();
746
int retval;
747
748
749
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
750
751
752
753
return -1;
}
if (!ctx) {
754
LocalReferenceHolder_Cleanup(&refs);
755
756
757
return -1;
}
758
759
jstring fileNameJString = (*mEnv)->NewStringUTF(mEnv, fileName);
ctx->hidden.androidio.fileNameRef = (*mEnv)->NewGlobalRef(mEnv, fileNameJString);
760
761
762
ctx->hidden.androidio.inputStreamRef = NULL;
ctx->hidden.androidio.readableByteChannelRef = NULL;
ctx->hidden.androidio.readMethod = NULL;
763
ctx->hidden.androidio.assetFileDescriptorRef = NULL;
764
765
766
767
retval = Internal_Android_JNI_FileOpen(ctx);
LocalReferenceHolder_Cleanup(&refs);
return retval;
768
769
}
770
size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,
771
772
size_t size, size_t maxnum)
{
773
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
774
775
776
777
778
779
780
781
782
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;
783
LocalReferenceHolder_Cleanup(&refs);
784
785
return result / size;
}
786
LocalReferenceHolder_Cleanup(&refs);
787
788
789
790
791
return 0;
} else {
jlong bytesRemaining = (jlong) (size * maxnum);
jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
int bytesRead = 0;
792
793
794
/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;
795
796
JNIEnv *mEnv = Android_JNI_GetEnv();
797
798
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
799
return 0;
800
}
801
802
803
jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
804
jobject byteBuffer = (*mEnv)->NewDirectByteBuffer(mEnv, buffer, bytesRemaining);
805
806
807
while (bytesRemaining > 0) {
// result = readableByteChannel.read(...);
808
int result = (*mEnv)->CallIntMethod(mEnv, readableByteChannel, readMethod, byteBuffer);
809
810
811
if (Android_JNI_ExceptionOccurred(false)) {
LocalReferenceHolder_Cleanup(&refs);
812
813
return 0;
}
814
815
816
817
if (result < 0) {
break;
}
818
819
820
821
822
bytesRemaining -= result;
bytesRead += result;
ctx->hidden.androidio.position += result;
}
823
LocalReferenceHolder_Cleanup(&refs);
824
return bytesRead / size;
825
}
826
827
}
828
size_t Android_JNI_FileWrite(SDL_RWops* ctx, const void* buffer,
829
830
831
832
833
834
size_t size, size_t num)
{
SDL_SetError("Cannot write to Android package filesystem");
return 0;
}
835
static int Internal_Android_JNI_FileClose(SDL_RWops* ctx, bool release)
836
{
837
838
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
839
840
841
int result = 0;
JNIEnv *mEnv = Android_JNI_GetEnv();
842
843
if (!LocalReferenceHolder_Init(&refs, mEnv)) {
LocalReferenceHolder_Cleanup(&refs);
844
return SDL_SetError("Failed to allocate enough JVM local references");
845
846
847
848
}
if (ctx) {
if (release) {
849
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
850
851
}
852
853
if (ctx->hidden.androidio.assetFileDescriptorRef) {
jobject inputStream = (jobject)ctx->hidden.androidio.assetFileDescriptorRef;
854
jmethodID mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
855
"close", "()V");
856
857
858
(*mEnv)->CallVoidMethod(mEnv, inputStream, mid);
(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
if (Android_JNI_ExceptionOccurred(false)) {
859
860
861
862
863
result = -1;
}
}
else {
jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;
864
865
// inputStream.close();
866
jmethodID mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, inputStream),
867
"close", "()V");
868
869
870
871
(*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)) {
872
873
result = -1;
}
874
875
876
877
878
879
880
}
if (release) {
SDL_FreeRW(ctx);
}
}
881
LocalReferenceHolder_Cleanup(&refs);
882
883
884
885
return result;
}
886
Sint64 Android_JNI_FileSize(SDL_RWops* ctx)
887
888
889
890
{
return ctx->hidden.androidio.size;
}
891
Sint64 Android_JNI_FileSeek(SDL_RWops* ctx, Sint64 offset, int whence)
892
{
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
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:
908
return SDL_SetError("Unknown value for 'whence'");
909
910
}
whence = SEEK_SET;
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
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:
929
return SDL_SetError("Unknown value for 'whence'");
930
}
931
932
933
/* Validate the new position */
if (newPosition < 0) {
934
return SDL_Error(SDL_EFSEEK);
935
936
937
938
}
if (newPosition > ctx->hidden.androidio.size) {
newPosition = ctx->hidden.androidio.size;
}
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
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;
957
958
}
959
960
961
} 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
962
963
Internal_Android_JNI_FileClose(ctx, false);
Internal_Android_JNI_FileOpen(ctx);
964
Android_JNI_FileSeek(ctx, newPosition, RW_SEEK_SET);
965
966
967
968
}
}
return ctx->hidden.androidio.position;
969
970
971
}
972
int Android_JNI_FileClose(SDL_RWops* ctx)
973
{
974
return Internal_Android_JNI_FileClose(ctx, true);
975
976
977
978
979
}
// returns a new global reference which needs to be released later
static jobject Android_JNI_GetSystemServiceObject(const char* name)
{
980
struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
981
JNIEnv* env = Android_JNI_GetEnv();
982
983
984
985
jobject retval = NULL;
if (!LocalReferenceHolder_Init(&refs, env)) {
LocalReferenceHolder_Cleanup(&refs);
986
987
988
return NULL;
}
989
jstring service = (*env)->NewStringUTF(env, name);
990
991
992
jmethodID mid;
993
994
mid = (*env)->GetStaticMethodID(env, mActivityClass, "getContext", "()Landroid/content/Context;");
jobject context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
995
996
997
mid = (*env)->GetMethodID(env, mActivityClass, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jobject manager = (*env)->CallObjectMethod(env, context, mid, service);
998
999
(*env)->DeleteLocalRef(env, service);
1000