4 * The Android-specific windows message processing methods.
6 * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7 * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8 * Copied for Platform code by Evan Felix <karcaw at gmail.com>
9 * Copyright (C) 2012 Sylvain Beucler
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
25 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 #include <GL/freeglut.h>
30 #include "fg_internal.h"
32 #include "egl/fg_window_egl.h"
34 #include <android/log.h>
35 #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__))
36 #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "FreeGLUT", __VA_ARGS__))
37 #include <android/native_app_glue/android_native_app_glue.h>
38 #include <android/keycodes.h>
40 static struct touchscreen touchscreen;
41 static unsigned char key_a2fg[256];
43 /* Cf. http://developer.android.com/reference/android/view/KeyEvent.html */
44 /* These codes are missing in <android/keycodes.h> */
45 /* Don't convert to enum, since it may conflict with future version of
46 that <android/keycodes.h> */
47 #define AKEYCODE_FORWARD_DEL 112
48 #define AKEYCODE_CTRL_LEFT 113
49 #define AKEYCODE_CTRL_RIGHT 114
50 #define AKEYCODE_MOVE_HOME 122
51 #define AKEYCODE_MOVE_END 123
52 #define AKEYCODE_INSERT 124
53 #define AKEYCODE_ESCAPE 127
54 #define AKEYCODE_F1 131
55 #define AKEYCODE_F2 132
56 #define AKEYCODE_F3 133
57 #define AKEYCODE_F4 134
58 #define AKEYCODE_F5 135
59 #define AKEYCODE_F6 136
60 #define AKEYCODE_F7 137
61 #define AKEYCODE_F8 138
62 #define AKEYCODE_F9 139
63 #define AKEYCODE_F10 140
64 #define AKEYCODE_F11 141
65 #define AKEYCODE_F12 142
67 #define EVENT_HANDLED 1
68 #define EVENT_NOT_HANDLED 0
71 * Initialize Android keycode to GLUT keycode mapping
73 static void key_init() {
74 memset(key_a2fg, 0, sizeof(key_a2fg));
76 key_a2fg[AKEYCODE_F1] = GLUT_KEY_F1;
77 key_a2fg[AKEYCODE_F2] = GLUT_KEY_F2;
78 key_a2fg[AKEYCODE_F3] = GLUT_KEY_F3;
79 key_a2fg[AKEYCODE_F4] = GLUT_KEY_F4;
80 key_a2fg[AKEYCODE_F5] = GLUT_KEY_F5;
81 key_a2fg[AKEYCODE_F6] = GLUT_KEY_F6;
82 key_a2fg[AKEYCODE_F7] = GLUT_KEY_F7;
83 key_a2fg[AKEYCODE_F8] = GLUT_KEY_F8;
84 key_a2fg[AKEYCODE_F9] = GLUT_KEY_F9;
85 key_a2fg[AKEYCODE_F10] = GLUT_KEY_F10;
86 key_a2fg[AKEYCODE_F11] = GLUT_KEY_F11;
87 key_a2fg[AKEYCODE_F12] = GLUT_KEY_F12;
89 key_a2fg[AKEYCODE_PAGE_UP] = GLUT_KEY_PAGE_UP;
90 key_a2fg[AKEYCODE_PAGE_DOWN] = GLUT_KEY_PAGE_DOWN;
91 key_a2fg[AKEYCODE_MOVE_HOME] = GLUT_KEY_HOME;
92 key_a2fg[AKEYCODE_MOVE_END] = GLUT_KEY_END;
93 key_a2fg[AKEYCODE_INSERT] = GLUT_KEY_INSERT;
95 key_a2fg[AKEYCODE_DPAD_UP] = GLUT_KEY_UP;
96 key_a2fg[AKEYCODE_DPAD_DOWN] = GLUT_KEY_DOWN;
97 key_a2fg[AKEYCODE_DPAD_LEFT] = GLUT_KEY_LEFT;
98 key_a2fg[AKEYCODE_DPAD_RIGHT] = GLUT_KEY_RIGHT;
100 key_a2fg[AKEYCODE_ALT_LEFT] = GLUT_KEY_ALT_L;
101 key_a2fg[AKEYCODE_ALT_RIGHT] = GLUT_KEY_ALT_R;
102 key_a2fg[AKEYCODE_SHIFT_LEFT] = GLUT_KEY_SHIFT_L;
103 key_a2fg[AKEYCODE_SHIFT_RIGHT] = GLUT_KEY_SHIFT_R;
104 key_a2fg[AKEYCODE_CTRL_LEFT] = GLUT_KEY_CTRL_L;
105 key_a2fg[AKEYCODE_CTRL_RIGHT] = GLUT_KEY_CTRL_R;
109 * Convert an Android key event to ASCII.
111 static unsigned char key_ascii(struct android_app* app, AInputEvent* event) {
112 int32_t code = AKeyEvent_getKeyCode(event);
114 /* Handle a few special cases: */
118 case AKEYCODE_FORWARD_DEL:
120 case AKEYCODE_ESCAPE:
124 /* Get usable JNI context */
125 JNIEnv* env = app->activity->env;
126 JavaVM* vm = app->activity->vm;
127 (*vm)->AttachCurrentThread(vm, &env, NULL);
129 jclass KeyEventClass = (*env)->FindClass(env, "android/view/KeyEvent");
130 jmethodID KeyEventConstructor = (*env)->GetMethodID(env, KeyEventClass, "<init>", "(II)V");
131 jobject keyEvent = (*env)->NewObject(env, KeyEventClass, KeyEventConstructor,
132 AKeyEvent_getAction(event), AKeyEvent_getKeyCode(event));
133 jmethodID KeyEvent_getUnicodeChar = (*env)->GetMethodID(env, KeyEventClass, "getUnicodeChar", "(I)I");
134 int ascii = (*env)->CallIntMethod(env, keyEvent, KeyEvent_getUnicodeChar, AKeyEvent_getMetaState(event));
136 /* LOGI("getUnicodeChar(%d) = %d ('%c')", AKeyEvent_getKeyCode(event), ascii, ascii); */
137 (*vm)->DetachCurrentThread(vm);
143 * Request a window resize
145 void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )
147 fprintf(stderr, "fgPlatformReshapeWindow: STUB\n");
151 * A static helper function to execute display callback for a window
153 void fgPlatformDisplayWindow ( SFG_Window *window )
155 fghRedrawWindow ( window ) ;
158 unsigned long fgPlatformSystemTime ( void )
161 gettimeofday( &now, NULL );
162 return now.tv_usec/1000 + now.tv_sec*1000;
166 * Does the magic required to relinquish the CPU until something interesting
169 void fgPlatformSleepForEvents( long msec )
171 /* Android's NativeActivity relies on a Looper/ALooper object to
172 notify about events. The Looper object is plugged on two
173 internal pipe(2)s to detect system and input events. Sadly you
174 can only ask the Looper for an event, not just ask whether
175 there is a pending event (and process it later). Consequently,
176 short of redesigning NativeActivity, we cannot
181 * Process the next input event.
183 int32_t handle_input(struct android_app* app, AInputEvent* event) {
184 SFG_Window* window = fgWindowByHandle(app->window);
186 return EVENT_NOT_HANDLED;
188 /* FIXME: in Android, when key is repeated, down and up events
189 happen most often at the exact same time. This makes it
190 impossible to animate based on key press time. */
191 /* e.g. down/up/wait/down/up rather than down/wait/down/wait/up */
193 if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) {
194 /* LOGI("action: %d", AKeyEvent_getAction(event)); */
195 /* LOGI("keycode: %d", code); */
196 int32_t code = AKeyEvent_getKeyCode(event);
198 if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN) {
199 int32_t keypress = 0;
200 unsigned char ascii = 0;
201 if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) {
202 INVOKE_WCB(*window, Special, (keypress, window->State.MouseX, window->State.MouseY));
203 return EVENT_HANDLED;
204 } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) {
205 INVOKE_WCB(*window, Keyboard, (ascii, window->State.MouseX, window->State.MouseY));
206 return EVENT_HANDLED;
209 else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP) {
210 int32_t keypress = 0;
211 unsigned char ascii = 0;
212 if ((keypress = key_a2fg[code]) && FETCH_WCB(*window, Special)) {
213 INVOKE_WCB(*window, SpecialUp, (keypress, window->State.MouseX, window->State.MouseY));
214 return EVENT_HANDLED;
215 } else if ((ascii = key_ascii(app, event)) && FETCH_WCB(*window, Keyboard)) {
216 INVOKE_WCB(*window, KeyboardUp, (ascii, window->State.MouseX, window->State.MouseY));
217 return EVENT_HANDLED;
222 if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
223 int32_t action = AMotionEvent_getAction(event);
224 float x = AMotionEvent_getX(event, 0);
225 float y = AMotionEvent_getY(event, 0);
226 LOGI("motion %.01f,%.01f action=%d", x, y, AMotionEvent_getAction(event));
228 /* Virtual arrows PAD */
229 /* Don't interfere with existing mouse move event */
230 if (!touchscreen.in_mmotion) {
231 struct vpad_state prev_vpad = touchscreen.vpad;
232 touchscreen.vpad.left = touchscreen.vpad.right
233 = touchscreen.vpad.up = touchscreen.vpad.down = false;
235 /* int32_t width = ANativeWindow_getWidth(window->Window.Handle); */
236 int32_t height = ANativeWindow_getHeight(window->Window.Handle);
237 if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_MOVE) {
238 if ((x > 0 && x < 100) && (y > (height - 100) && y < height))
239 touchscreen.vpad.left = true;
240 if ((x > 200 && x < 300) && (y > (height - 100) && y < height))
241 touchscreen.vpad.right = true;
242 if ((x > 100 && x < 200) && (y > (height - 100) && y < height))
243 touchscreen.vpad.down = true;
244 if ((x > 100 && x < 200) && (y > (height - 200) && y < (height - 100)))
245 touchscreen.vpad.up = true;
247 if (action == AMOTION_EVENT_ACTION_DOWN &&
248 (touchscreen.vpad.left || touchscreen.vpad.right || touchscreen.vpad.down || touchscreen.vpad.up))
249 touchscreen.vpad.on = true;
250 if (action == AMOTION_EVENT_ACTION_UP)
251 touchscreen.vpad.on = false;
252 if (prev_vpad.left != touchscreen.vpad.left
253 || prev_vpad.right != touchscreen.vpad.right
254 || prev_vpad.up != touchscreen.vpad.up
255 || prev_vpad.down != touchscreen.vpad.down
256 || prev_vpad.on != touchscreen.vpad.on) {
257 if (FETCH_WCB(*window, Special)) {
258 if (prev_vpad.left == false && touchscreen.vpad.left == true)
259 INVOKE_WCB(*window, Special, (GLUT_KEY_LEFT, x, y));
260 else if (prev_vpad.right == false && touchscreen.vpad.right == true)
261 INVOKE_WCB(*window, Special, (GLUT_KEY_RIGHT, x, y));
262 else if (prev_vpad.up == false && touchscreen.vpad.up == true)
263 INVOKE_WCB(*window, Special, (GLUT_KEY_UP, x, y));
264 else if (prev_vpad.down == false && touchscreen.vpad.down == true)
265 INVOKE_WCB(*window, Special, (GLUT_KEY_DOWN, x, y));
267 if (FETCH_WCB(*window, SpecialUp)) {
268 if (prev_vpad.left == true && touchscreen.vpad.left == false)
269 INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_LEFT, x, y));
270 if (prev_vpad.right == true && touchscreen.vpad.right == false)
271 INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_RIGHT, x, y));
272 if (prev_vpad.up == true && touchscreen.vpad.up == false)
273 INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_UP, x, y));
274 if (prev_vpad.down == true && touchscreen.vpad.down == false)
275 INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_DOWN, x, y));
277 return EVENT_HANDLED;
281 /* Normal mouse events */
282 if (!touchscreen.vpad.on) {
283 window->State.MouseX = x;
284 window->State.MouseY = y;
285 LOGI("Changed mouse position: %f,%f", x, y);
286 if (action == AMOTION_EVENT_ACTION_DOWN && FETCH_WCB(*window, Mouse)) {
287 touchscreen.in_mmotion = true;
288 INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_DOWN, x, y));
289 } else if (action == AMOTION_EVENT_ACTION_UP && FETCH_WCB(*window, Mouse)) {
290 touchscreen.in_mmotion = false;
291 INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_UP, x, y));
292 } else if (action == AMOTION_EVENT_ACTION_MOVE && FETCH_WCB(*window, Motion)) {
293 INVOKE_WCB(*window, Motion, (x, y));
297 return EVENT_HANDLED;
300 /* Let Android handle other events (e.g. Back and Menu buttons) */
301 return EVENT_NOT_HANDLED;
305 * Process the next main command.
307 void handle_cmd(struct android_app* app, int32_t cmd) {
308 SFG_Window* window = fgWindowByHandle(app->window); /* may be NULL */
310 /* App life cycle, in that order: */
312 LOGI("handle_cmd: APP_CMD_START");
315 LOGI("handle_cmd: APP_CMD_RESUME");
316 /* Cf. fgPlatformProcessSingleEvent */
318 case APP_CMD_INIT_WINDOW: /* surfaceCreated */
319 /* The window is being shown, get it ready. */
320 LOGI("handle_cmd: APP_CMD_INIT_WINDOW");
321 fgDisplay.pDisplay.single_native_window = app->window;
322 /* glPlatformOpenWindow was waiting for Handle to be defined and
323 will now return from fgPlatformProcessSingleEvent() */
325 case APP_CMD_GAINED_FOCUS:
326 LOGI("handle_cmd: APP_CMD_GAINED_FOCUS");
328 case APP_CMD_WINDOW_RESIZED:
329 LOGI("handle_cmd: APP_CMD_WINDOW_RESIZED");
330 if (window->Window.pContext.egl.Surface != EGL_NO_SURFACE)
331 /* Make ProcessSingleEvent detect the new size, only available
332 after the next SwapBuffer */
336 case APP_CMD_SAVE_STATE: /* onSaveInstanceState */
337 /* The system has asked us to save our current state, when it
338 pauses the application without destroying it right after. */
339 app->savedState = strdup("Detect me as non-NULL on next android_main");
340 app->savedStateSize = strlen(app->savedState) + 1;
341 LOGI("handle_cmd: APP_CMD_SAVE_STATE");
344 LOGI("handle_cmd: APP_CMD_PAUSE");
345 /* Cf. fgPlatformProcessSingleEvent */
347 case APP_CMD_LOST_FOCUS:
348 LOGI("handle_cmd: APP_CMD_LOST_FOCUS");
350 case APP_CMD_TERM_WINDOW: /* surfaceDestroyed */
351 /* The application is being hidden, but may be restored */
352 LOGI("handle_cmd: APP_CMD_TERM_WINDOW");
353 fghPlatformCloseWindowEGL(window);
354 fgDisplay.pDisplay.single_native_window = NULL;
357 LOGI("handle_cmd: APP_CMD_STOP");
359 case APP_CMD_DESTROY: /* Activity.onDestroy */
360 LOGI("handle_cmd: APP_CMD_DESTROY");
361 /* User closed the application for good, let's kill the window */
363 /* Can't use fgWindowByHandle as app->window is NULL */
364 SFG_Window* window = fgStructure.CurrentWindow;
365 if (window != NULL) {
366 fgDestroyWindow(window);
368 LOGI("APP_CMD_DESTROY: No current window");
371 /* glue has already set android_app->destroyRequested=1 */
374 case APP_CMD_CONFIG_CHANGED:
375 /* Handle rotation / orientation change */
376 LOGI("handle_cmd: APP_CMD_CONFIG_CHANGED");
378 case APP_CMD_LOW_MEMORY:
379 LOGI("handle_cmd: APP_CMD_LOW_MEMORY");
382 LOGI("handle_cmd: unhandled cmd=%d", cmd);
386 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
387 GLboolean positionUse, int x, int y,
388 GLboolean sizeUse, int w, int h,
389 GLboolean gameMode, GLboolean isSubWindow );
391 void fgPlatformProcessSingleEvent ( void )
393 /* When the screen is resized, the window handle still points to the
394 old window until the next SwapBuffer, while it's crucial to set
395 the size (onShape) correctly before the next onDisplay callback.
396 Plus we don't know if the next SwapBuffer already occurred at the
397 time we process the event (e.g. during onDisplay). */
398 /* So we do the check each time rather than on event. */
399 /* Interestingly, on a Samsung Galaxy S/PowerVR SGX540 GPU/Android
400 2.3, that next SwapBuffer is fake (but still necessary to get the
402 SFG_Window* window = fgStructure.CurrentWindow;
403 if (window != NULL && window->Window.Handle != NULL) {
404 int32_t width = ANativeWindow_getWidth(window->Window.Handle);
405 int32_t height = ANativeWindow_getHeight(window->Window.Handle);
406 if (width != window->State.pWState.LastWidth || height != window->State.pWState.LastHeight) {
407 window->State.pWState.LastWidth = width;
408 window->State.pWState.LastHeight = height;
409 LOGI("width=%d, height=%d", width, height);
410 if( FETCH_WCB( *window, Reshape ) )
411 INVOKE_WCB( *window, Reshape, ( width, height ) );
413 glViewport( 0, 0, width, height );
418 /* Read pending event. */
421 struct android_poll_source* source;
422 /* This is called "ProcessSingleEvent" but this means we'd only
423 process ~60 (screen Hz) mouse events per second, plus other ports
424 are processing all events already. So let's process all pending
426 /* if ((ident=ALooper_pollOnce(0, NULL, &events, (void**)&source)) >= 0) { */
427 while ((ident=ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0) {
428 /* Process this event. */
429 if (source != NULL) {
430 source->process(source->app, source);
434 /* If we're not in RESUME state, Android paused us, so wait */
435 struct android_app* app = fgDisplay.pDisplay.app;
436 if (app->destroyRequested != 1 && app->activityState != APP_CMD_RESUME) {
438 while (app->destroyRequested != 1 && (app->activityState != APP_CMD_RESUME)) {
439 if ((ident=ALooper_pollOnce(FOREVER, NULL, &events, (void**)&source)) >= 0) {
440 /* Process this event. */
441 if (source != NULL) {
442 source->process(source->app, source);
446 /* If coming back from a pause: */
447 /* - Recreate window context and surface */
448 /* - Call user-defined hook to restore resources (textures...) */
449 /* - Exit pause looop */
450 if (app->destroyRequested != 1) {
451 /* Android is full-screen only, simplified call.. */
452 /* Ideally we'd have a fgPlatformReopenWindow() */
453 fgPlatformOpenWindow(window, "", GL_FALSE, 0, 0, GL_FALSE, 0, 0, GL_FALSE, GL_FALSE);
454 /* TODO: INVOKE_WCB(*window, Pause?); */
455 /* TODO: INVOKE_WCB(*window, LoadResources/ContextLost/...?); */
456 /* TODO: INVOKE_WCB(*window, Resume?); */
461 void fgPlatformMainLoopPreliminaryWork ( void )
463 LOGI("fgPlatformMainLoopPreliminaryWork\n");
467 /* Make sure glue isn't stripped. */
468 /* JNI entry points need to be bundled even when linking statically */