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