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