src/video/android/SDL_androidevents.c
author Sylvain Becker
Fri, 12 Apr 2019 23:15:26 +0200
changeset 12703 f6c7e5e03f60
parent 12693 d311fcb8066a
child 12712 66a50635b3e8
permissions -rw-r--r--
Android: when event loop is not blocking in pause, backup EGL context (Bug 4578)
Backup the EGL context when SDL_APP_DIDENTERBACKGROUND has been removed from the
event queue.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../../SDL_internal.h"
    22 
    23 #if SDL_VIDEO_DRIVER_ANDROID
    24 
    25 #include "SDL_androidevents.h"
    26 #include "SDL_events.h"
    27 #include "SDL_androidkeyboard.h"
    28 #include "SDL_androidwindow.h"
    29 
    30 /* Can't include sysaudio "../../audio/android/SDL_androidaudio.h"
    31  * because of THIS redefinition */
    32 
    33 #if !SDL_AUDIO_DISABLED && SDL_AUDIO_DRIVER_ANDROID
    34 extern void ANDROIDAUDIO_ResumeDevices(void);
    35 extern void ANDROIDAUDIO_PauseDevices(void);
    36 #else
    37 static void ANDROIDAUDIO_ResumeDevices(void) {}
    38 static void ANDROIDAUDIO_PauseDevices(void) {}
    39 #endif
    40 
    41 #if !SDL_AUDIO_DISABLED && SDL_AUDIO_DRIVER_OPENSLES
    42 extern void openslES_ResumeDevices(void);
    43 extern void openslES_PauseDevices(void);
    44 #else
    45 static void openslES_ResumeDevices(void) {}
    46 static void openslES_PauseDevices(void) {}
    47 #endif
    48 
    49 /* Number of 'type' events in the event queue */
    50 static int
    51 SDL_NumberOfEvents(Uint32 type)
    52 {
    53     return SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type);
    54 }
    55 
    56 static void
    57 android_egl_context_restore(SDL_Window *window)
    58 {
    59     if (window) {
    60         SDL_Event event;
    61         SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
    62         if (SDL_GL_MakeCurrent(window, (SDL_GLContext) data->egl_context) < 0) {
    63             /* The context is no longer valid, create a new one */
    64             data->egl_context = (EGLContext) SDL_GL_CreateContext(window);
    65             SDL_GL_MakeCurrent(window, (SDL_GLContext) data->egl_context);
    66             event.type = SDL_RENDER_DEVICE_RESET;
    67             SDL_PushEvent(&event);
    68         }
    69     }
    70 }
    71 
    72 static void
    73 android_egl_context_backup(SDL_Window *window)
    74 {
    75     if (window) {
    76         /* Keep a copy of the EGL Context so we can try to restore it when we resume */
    77         SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
    78         data->egl_context = SDL_GL_GetCurrentContext();
    79         /* We need to do this so the EGLSurface can be freed */
    80         SDL_GL_MakeCurrent(window, NULL);
    81     }
    82 }
    83 
    84 
    85 /*
    86  * Android_ResumeSem and Android_PauseSem are signaled from Java_org_libsdl_app_SDLActivity_nativePause and Java_org_libsdl_app_SDLActivity_nativeResume
    87  * When the pause semaphore is signaled, if Android_PumpEvents_Blocking is used, the event loop will block until the resume signal is emitted.
    88  *
    89  * No polling necessary
    90  */
    91 
    92 void
    93 Android_PumpEvents_Blocking(_THIS)
    94 {
    95     SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
    96 
    97     if (videodata->isPaused) {
    98 
    99         /* Make sure this is the last thing we do before pausing */
   100         SDL_LockMutex(Android_ActivityMutex);
   101         android_egl_context_backup(Android_Window);
   102         SDL_UnlockMutex(Android_ActivityMutex);
   103 
   104         ANDROIDAUDIO_PauseDevices();
   105         openslES_PauseDevices();
   106 
   107         if (SDL_SemWait(Android_ResumeSem) == 0) {
   108 
   109             videodata->isPaused = 0;
   110 
   111             ANDROIDAUDIO_ResumeDevices();
   112             openslES_ResumeDevices();
   113 
   114             /* Restore the GL Context from here, as this operation is thread dependent */
   115             if (!SDL_HasEvent(SDL_QUIT)) {
   116                 SDL_LockMutex(Android_ActivityMutex);
   117                 android_egl_context_restore(Android_Window);
   118                 SDL_UnlockMutex(Android_ActivityMutex);
   119             }
   120 
   121             /* Make sure SW Keyboard is restored when an app becomes foreground */
   122             if (SDL_IsTextInputActive()) {
   123                 Android_StartTextInput(_this); /* Only showTextInput */
   124             }
   125         }
   126     } else {
   127         if (videodata->isPausing || SDL_SemTryWait(Android_PauseSem) == 0) {
   128             /* We've been signaled to pause (potentially several times), but before we block ourselves,
   129              * we need to make sure that the very last event (of the first pause sequence, if several)
   130              * has reached the app */
   131             if (SDL_NumberOfEvents(SDL_APP_DIDENTERBACKGROUND) > SDL_SemValue(Android_PauseSem)) {
   132                 videodata->isPausing = 1;
   133             } else {
   134                 videodata->isPausing = 0;
   135                 videodata->isPaused = 1;
   136             }
   137         }
   138     }
   139 }
   140 
   141 void
   142 Android_PumpEvents_NonBlocking(_THIS)
   143 {
   144     SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
   145     static int backup_context;
   146 
   147     if (videodata->isPaused) {
   148 
   149         if (backup_context) {
   150 
   151             SDL_LockMutex(Android_ActivityMutex);
   152             android_egl_context_backup(Android_Window);
   153             SDL_UnlockMutex(Android_ActivityMutex);
   154 
   155             ANDROIDAUDIO_PauseDevices();
   156             openslES_PauseDevices();
   157 
   158             backup_context = 0;
   159         }
   160 
   161 
   162         if (SDL_SemTryWait(Android_ResumeSem) == 0) {
   163 
   164             videodata->isPaused = 0;
   165 
   166             ANDROIDAUDIO_ResumeDevices();
   167             openslES_ResumeDevices();
   168 
   169             /* Restore the GL Context from here, as this operation is thread dependent */
   170             if (!SDL_HasEvent(SDL_QUIT)) {
   171                 SDL_LockMutex(Android_ActivityMutex);
   172                 android_egl_context_restore(Android_Window);
   173                 SDL_UnlockMutex(Android_ActivityMutex);
   174             }
   175 
   176             /* Make sure SW Keyboard is restored when an app becomes foreground */
   177             if (SDL_IsTextInputActive()) {
   178                 Android_StartTextInput(_this); /* Only showTextInput */
   179             }
   180         }
   181     } else {
   182         if (videodata->isPausing || SDL_SemTryWait(Android_PauseSem) == 0) {
   183             /* We've been signaled to pause (potentially several times), but before we block ourselves,
   184              * we need to make sure that the very last event (of the first pause sequence, if several)
   185              * has reached the app */
   186             if (SDL_NumberOfEvents(SDL_APP_DIDENTERBACKGROUND) > SDL_SemValue(Android_PauseSem)) {
   187                 videodata->isPausing = 1;
   188             } else {
   189                 videodata->isPausing = 0;
   190                 videodata->isPaused = 1;
   191                 backup_context = 1;
   192             }
   193         }
   194     }
   195 }
   196 
   197 #endif /* SDL_VIDEO_DRIVER_ANDROID */
   198 
   199 /* vi: set ts=4 sw=4 expandtab: */