X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Fandroid%2Ffg_main_android.c;h=77d5b967565e29ac18281367ffc0f88fffae0995;hb=18530d133238f83763d65e8384111eafe21fd382;hp=1e30b1061b82a0d241fc4fc7e092e872ab8fe56f;hpb=329ff5a3e911e6a0e6cf4d75f25f9ccedd3b7693;p=freeglut diff --git a/src/android/fg_main_android.c b/src/android/fg_main_android.c index 1e30b10..77d5b96 100644 --- a/src/android/fg_main_android.c +++ b/src/android/fg_main_android.c @@ -29,6 +29,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__)) @@ -180,12 +181,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 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)); */ @@ -302,50 +308,89 @@ 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"); - 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() */ + /* App life cycle, in that order: */ + case APP_CMD_START: + LOGI("handle_cmd: APP_CMD_START"); 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; + case APP_CMD_RESUME: + LOGI("handle_cmd: APP_CMD_RESUME"); + /* Cf. fgPlatformProcessSingleEvent */ 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); + 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 +402,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 +433,35 @@ 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) { + 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); + } + } + } + /* If 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); + /* TODO: INVOKE_WCB(*window, Pause?); */ + /* TODO: INVOKE_WCB(*window, LoadResources/ContextLost/...?); */ + /* TODO: INVOKE_WCB(*window, Resume?); */ + } + } } void fgPlatformMainLoopPreliminaryWork ( void )