X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Fandroid%2Ffg_main_android.c;h=15d31e62394f347e777ef0668d71c002d0ab24dc;hb=4a451851ec51ea7c3b79534fa5faebadceedf4df;hp=1e30b1061b82a0d241fc4fc7e092e872ab8fe56f;hpb=329ff5a3e911e6a0e6cf4d75f25f9ccedd3b7693;p=freeglut diff --git a/src/android/fg_main_android.c b/src/android/fg_main_android.c index 1e30b10..15d31e6 100644 --- a/src/android/fg_main_android.c +++ b/src/android/fg_main_android.c @@ -28,7 +28,7 @@ #include #include "fg_internal.h" -#include "fg_main.h" +#include "egl/fg_window_egl.h" #include #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FreeGLUT", __VA_ARGS__)) @@ -138,22 +138,6 @@ static unsigned char key_ascii(struct android_app* app, AInputEvent* event) { return ascii; } -/* - * Request a window resize - */ -void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height ) -{ - fprintf(stderr, "fgPlatformReshapeWindow: STUB\n"); -} - -/* - * A static helper function to execute display callback for a window - */ -void fgPlatformDisplayWindow ( SFG_Window *window ) -{ - fghRedrawWindow ( window ) ; -} - unsigned long fgPlatformSystemTime ( void ) { struct timeval now; @@ -180,12 +164,17 @@ void fgPlatformSleepForEvents( long msec ) * Process the next input event. */ int32_t handle_input(struct android_app* app, AInputEvent* event) { - SFG_Window* window = fgStructure.CurrentWindow; - - /* FIXME: in Android, when key is repeated, down and up events - happen most often at the exact same time. This makes it - impossible to animate based on key press time. */ - /* e.g. down/up/wait/down/up rather than down/wait/down/wait/up */ + SFG_Window* window = fgWindowByHandle(app->window); + if (window == NULL) + return EVENT_NOT_HANDLED; + + /* FIXME: in Android, when a key is repeated, down + and up events happen most often at the exact same time. This + makes it impossible to animate based on key press time. */ + /* e.g. down/up/wait/down/up rather than down/wait/down/wait/up */ + /* This looks like a bug in the Android virtual keyboard system :/ + Real buttons such as the Back button appear to work correctly + (series of down events with proper getRepeatCount value). */ if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) { /* LOGI("action: %d", AKeyEvent_getAction(event)); */ @@ -216,12 +205,27 @@ int32_t handle_input(struct android_app* app, AInputEvent* event) { } } - if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) { - int32_t action = AMotionEvent_getAction(event); + int32_t source = AInputEvent_getSource(event); + if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION + && source == AINPUT_SOURCE_TOUCHSCREEN) { + int32_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK; + /* Pointer ID for clicks */ + int32_t pidx = AMotionEvent_getAction(event) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; + /* TODO: Handle multi-touch; also handle multiple sources/devices */ + /* cf. http://sourceforge.net/mailarchive/forum.php?thread_name=20120518071314.GA28061%40perso.beuc.net&forum_name=freeglut-developer */ + if (0) { + LOGI("motion action=%d index=%d source=%d", action, pidx, source); + int count = AMotionEvent_getPointerCount(event); + int i; + for (i = 0; i < count; i++) { + LOGI("multi(%d): %.01f,%.01f", + AMotionEvent_getPointerId(event, i), + AMotionEvent_getX(event, i), AMotionEvent_getY(event, i)); + } + } float x = AMotionEvent_getX(event, 0); float y = AMotionEvent_getY(event, 0); - LOGI("motion %.01f,%.01f action=%d", x, y, AMotionEvent_getAction(event)); - + /* Virtual arrows PAD */ /* Don't interfere with existing mouse move event */ if (!touchscreen.in_mmotion) { @@ -279,7 +283,6 @@ int32_t handle_input(struct android_app* app, AInputEvent* event) { if (!touchscreen.vpad.on) { window->State.MouseX = x; window->State.MouseY = y; - LOGI("Changed mouse position: %f,%f", x, y); if (action == AMOTION_EVENT_ACTION_DOWN && FETCH_WCB(*window, Mouse)) { touchscreen.in_mmotion = true; INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, GLUT_DOWN, x, y)); @@ -302,50 +305,90 @@ int32_t handle_input(struct android_app* app, AInputEvent* event) { * Process the next main command. */ void handle_cmd(struct android_app* app, int32_t cmd) { + SFG_Window* window = fgWindowByHandle(app->window); /* may be NULL */ switch (cmd) { - case APP_CMD_SAVE_STATE: - /* The system has asked us to save our current state. Do so. */ - LOGI("handle_cmd: APP_CMD_SAVE_STATE"); + /* App life cycle, in that order: */ + case APP_CMD_START: + LOGI("handle_cmd: APP_CMD_START"); break; - case APP_CMD_INIT_WINDOW: - /* The window is being shown, get it ready. */ - LOGI("handle_cmd: APP_CMD_INIT_WINDOW"); - fgDisplay.pDisplay.single_window->Window.Handle = app->window; - /* glPlatformOpenWindow was waiting for Handle to be defined and - will now return from fgPlatformProcessSingleEvent() */ + case APP_CMD_RESUME: + LOGI("handle_cmd: APP_CMD_RESUME"); + /* Cf. fgPlatformProcessSingleEvent */ break; - case APP_CMD_TERM_WINDOW: - /* The window is being hidden or closed, clean it up. */ - LOGI("handle_cmd: APP_CMD_TERM_WINDOW"); - fgDestroyWindow(fgDisplay.pDisplay.single_window); - fgDisplay.pDisplay.single_window = NULL; - break; - case APP_CMD_DESTROY: - LOGI("handle_cmd: APP_CMD_DESTROY"); - /* glue has already set android_app->destroyRequested=1 */ + case APP_CMD_INIT_WINDOW: /* surfaceCreated */ + /* The window is being shown, get it ready. */ + LOGI("handle_cmd: APP_CMD_INIT_WINDOW %p", app->window); + fgDisplay.pDisplay.single_native_window = app->window; + /* start|resume: glPlatformOpenWindow was waiting for Handle to be + defined and will now continue processing */ break; case APP_CMD_GAINED_FOCUS: LOGI("handle_cmd: APP_CMD_GAINED_FOCUS"); break; + case APP_CMD_WINDOW_RESIZED: + LOGI("handle_cmd: APP_CMD_WINDOW_RESIZED"); + if (window->Window.pContext.egl.Surface != EGL_NO_SURFACE) + /* Make ProcessSingleEvent detect the new size, only available + after the next SwapBuffer */ + glutPostRedisplay(); + break; + + case APP_CMD_SAVE_STATE: /* onSaveInstanceState */ + /* The system has asked us to save our current state, when it + pauses the application without destroying it right after. */ + app->savedState = strdup("Detect me as non-NULL on next android_main"); + app->savedStateSize = strlen(app->savedState) + 1; + LOGI("handle_cmd: APP_CMD_SAVE_STATE"); + break; + case APP_CMD_PAUSE: + LOGI("handle_cmd: APP_CMD_PAUSE"); + /* Cf. fgPlatformProcessSingleEvent */ + break; case APP_CMD_LOST_FOCUS: LOGI("handle_cmd: APP_CMD_LOST_FOCUS"); break; + case APP_CMD_TERM_WINDOW: /* surfaceDestroyed */ + /* The application is being hidden, but may be restored */ + LOGI("handle_cmd: APP_CMD_TERM_WINDOW"); + fghPlatformCloseWindowEGL(window); + window->State.NeedToInitContext = GL_TRUE; + fgDisplay.pDisplay.single_native_window = NULL; + break; + case APP_CMD_STOP: + LOGI("handle_cmd: APP_CMD_STOP"); + break; + case APP_CMD_DESTROY: /* Activity.onDestroy */ + LOGI("handle_cmd: APP_CMD_DESTROY"); + /* User closed the application for good, let's kill the window */ + { + /* Can't use fgWindowByHandle as app->window is NULL */ + SFG_Window* window = fgStructure.CurrentWindow; + if (window != NULL) { + fgDestroyWindow(window); + } else { + LOGI("APP_CMD_DESTROY: No current window"); + } + } + /* glue has already set android_app->destroyRequested=1 */ + break; + case APP_CMD_CONFIG_CHANGED: /* Handle rotation / orientation change */ LOGI("handle_cmd: APP_CMD_CONFIG_CHANGED"); break; - case APP_CMD_WINDOW_RESIZED: - LOGI("handle_cmd: APP_CMD_WINDOW_RESIZED"); - if (fgDisplay.pDisplay.single_window->Window.pContext.egl.Surface != EGL_NO_SURFACE) - /* Make ProcessSingleEvent detect the new size, only available - after the next SwapBuffer */ - glutPostRedisplay(); + case APP_CMD_LOW_MEMORY: + LOGI("handle_cmd: APP_CMD_LOW_MEMORY"); break; default: LOGI("handle_cmd: unhandled cmd=%d", cmd); } } +void fgPlatformOpenWindow( SFG_Window* window, const char* title, + GLboolean positionUse, int x, int y, + GLboolean sizeUse, int w, int h, + GLboolean gameMode, GLboolean isSubWindow ); + void fgPlatformProcessSingleEvent ( void ) { /* When the screen is resized, the window handle still points to the @@ -357,7 +400,7 @@ void fgPlatformProcessSingleEvent ( void ) /* Interestingly, on a Samsung Galaxy S/PowerVR SGX540 GPU/Android 2.3, that next SwapBuffer is fake (but still necessary to get the new size). */ - SFG_Window* window = fgDisplay.pDisplay.single_window; + SFG_Window* window = fgStructure.CurrentWindow; if (window != NULL && window->Window.Handle != NULL) { int32_t width = ANativeWindow_getWidth(window->Window.Handle); int32_t height = ANativeWindow_getHeight(window->Window.Handle); @@ -388,6 +431,39 @@ void fgPlatformProcessSingleEvent ( void ) source->process(source->app, source); } } + + /* If we're not in RESUME state, Android paused us, so wait */ + struct android_app* app = fgDisplay.pDisplay.app; + if (app->destroyRequested != 1 && app->activityState != APP_CMD_RESUME) { + INVOKE_WCB(*window, Pause, ()); + + int FOREVER = -1; + while (app->destroyRequested != 1 && (app->activityState != APP_CMD_RESUME)) { + if ((ident=ALooper_pollOnce(FOREVER, NULL, &events, (void**)&source)) >= 0) { + /* Process this event. */ + if (source != NULL) { + source->process(source->app, source); + } + } + } + /* Coming back from a pause: */ + /* - Recreate window context and surface */ + /* - Call user-defined hook to restore resources (textures...) */ + /* - Exit pause looop */ + if (app->destroyRequested != 1) { + /* Android is full-screen only, simplified call.. */ + /* Ideally we'd have a fgPlatformReopenWindow() */ + /* If we're hidden by a non-fullscreen or translucent activity, + we'll be paused but not stopped, and keep the current + surface; in which case fgPlatformOpenWindow will no-op. */ + fgPlatformOpenWindow(window, "", GL_FALSE, 0, 0, GL_FALSE, 0, 0, GL_FALSE, GL_FALSE); + + if (!FETCH_WCB(*window, InitContext)) + fgWarning("Resuming application, but no callback to reload context resources (glutInitContextFunc)"); + } + + INVOKE_WCB(*window, Resume, ()); + } } void fgPlatformMainLoopPreliminaryWork ( void )