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