src/video/android/SDL_androidvideo.c
author Sam Lantinga <slouken@libsdl.org>
Mon, 28 Aug 2017 00:43:14 -0700
changeset 11383 6cafb5954aaf
parent 11381 2610f8f0a9c6
child 11662 a996f135cc81
permissions -rw-r--r--
Fixed mingw Windows build, since SDL_vulkan_internal.h includes windows.h
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2017 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 /* Android SDL video driver implementation
    26 */
    27 
    28 #include "SDL_video.h"
    29 #include "SDL_mouse.h"
    30 #include "../SDL_sysvideo.h"
    31 #include "../SDL_pixels_c.h"
    32 #include "../../events/SDL_events_c.h"
    33 #include "../../events/SDL_windowevents_c.h"
    34 
    35 #include "SDL_androidvideo.h"
    36 #include "SDL_androidgl.h"
    37 #include "SDL_androidclipboard.h"
    38 #include "SDL_androidevents.h"
    39 #include "SDL_androidkeyboard.h"
    40 #include "SDL_androidmouse.h"
    41 #include "SDL_androidtouch.h"
    42 #include "SDL_androidwindow.h"
    43 #include "SDL_androidvulkan.h"
    44 
    45 #define ANDROID_VID_DRIVER_NAME "Android"
    46 
    47 /* Initialization/Query functions */
    48 static int Android_VideoInit(_THIS);
    49 static void Android_VideoQuit(_THIS);
    50 
    51 #include "../SDL_egl_c.h"
    52 #define Android_GLES_GetProcAddress SDL_EGL_GetProcAddress
    53 #define Android_GLES_UnloadLibrary SDL_EGL_UnloadLibrary
    54 #define Android_GLES_SetSwapInterval SDL_EGL_SetSwapInterval
    55 #define Android_GLES_GetSwapInterval SDL_EGL_GetSwapInterval
    56 #define Android_GLES_DeleteContext SDL_EGL_DeleteContext
    57 
    58 /* Android driver bootstrap functions */
    59 
    60 
    61 /* These are filled in with real values in Android_SetScreenResolution on init (before SDL_main()) */
    62 int Android_ScreenWidth = 0;
    63 int Android_ScreenHeight = 0;
    64 Uint32 Android_ScreenFormat = SDL_PIXELFORMAT_UNKNOWN;
    65 static int Android_ScreenRate = 0;
    66 
    67 SDL_sem *Android_PauseSem = NULL, *Android_ResumeSem = NULL;
    68 
    69 /* Currently only one window */
    70 SDL_Window *Android_Window = NULL;
    71 
    72 static int
    73 Android_Available(void)
    74 {
    75     return 1;
    76 }
    77 
    78 static void
    79 Android_SuspendScreenSaver(_THIS)
    80 {
    81     Android_JNI_SuspendScreenSaver(_this->suspend_screensaver);
    82 }
    83 
    84 static void
    85 Android_DeleteDevice(SDL_VideoDevice * device)
    86 {
    87     SDL_free(device->driverdata);
    88     SDL_free(device);
    89 }
    90 
    91 static SDL_VideoDevice *
    92 Android_CreateDevice(int devindex)
    93 {
    94     SDL_VideoDevice *device;
    95     SDL_VideoData *data;
    96 
    97     /* Initialize all variables that we clean on shutdown */
    98     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
    99     if (!device) {
   100         SDL_OutOfMemory();
   101         return NULL;
   102     }
   103 
   104     data = (SDL_VideoData*) SDL_calloc(1, sizeof(SDL_VideoData));
   105     if (!data) {
   106         SDL_OutOfMemory();
   107         SDL_free(device);
   108         return NULL;
   109     }
   110 
   111     device->driverdata = data;
   112 
   113     /* Set the function pointers */
   114     device->VideoInit = Android_VideoInit;
   115     device->VideoQuit = Android_VideoQuit;
   116     device->PumpEvents = Android_PumpEvents;
   117 
   118     device->CreateSDLWindow = Android_CreateWindow;
   119     device->SetWindowTitle = Android_SetWindowTitle;
   120     device->DestroyWindow = Android_DestroyWindow;
   121     device->GetWindowWMInfo = Android_GetWindowWMInfo;
   122 
   123     device->free = Android_DeleteDevice;
   124 
   125     /* GL pointers */
   126     device->GL_LoadLibrary = Android_GLES_LoadLibrary;
   127     device->GL_GetProcAddress = Android_GLES_GetProcAddress;
   128     device->GL_UnloadLibrary = Android_GLES_UnloadLibrary;
   129     device->GL_CreateContext = Android_GLES_CreateContext;
   130     device->GL_MakeCurrent = Android_GLES_MakeCurrent;
   131     device->GL_SetSwapInterval = Android_GLES_SetSwapInterval;
   132     device->GL_GetSwapInterval = Android_GLES_GetSwapInterval;
   133     device->GL_SwapWindow = Android_GLES_SwapWindow;
   134     device->GL_DeleteContext = Android_GLES_DeleteContext;
   135 
   136 #if SDL_VIDEO_VULKAN
   137     device->Vulkan_LoadLibrary = Android_Vulkan_LoadLibrary;
   138     device->Vulkan_UnloadLibrary = Android_Vulkan_UnloadLibrary;
   139     device->Vulkan_GetInstanceExtensions = Android_Vulkan_GetInstanceExtensions;
   140     device->Vulkan_CreateSurface = Android_Vulkan_CreateSurface;
   141 #endif
   142 
   143     /* Screensaver */
   144     device->SuspendScreenSaver = Android_SuspendScreenSaver;
   145 
   146     /* Text input */
   147     device->StartTextInput = Android_StartTextInput;
   148     device->StopTextInput = Android_StopTextInput;
   149     device->SetTextInputRect = Android_SetTextInputRect;
   150 
   151     /* Screen keyboard */
   152     device->HasScreenKeyboardSupport = Android_HasScreenKeyboardSupport;
   153     device->IsScreenKeyboardShown = Android_IsScreenKeyboardShown;
   154 
   155     /* Clipboard */
   156     device->SetClipboardText = Android_SetClipboardText;
   157     device->GetClipboardText = Android_GetClipboardText;
   158     device->HasClipboardText = Android_HasClipboardText;
   159 
   160     return device;
   161 }
   162 
   163 VideoBootStrap Android_bootstrap = {
   164     ANDROID_VID_DRIVER_NAME, "SDL Android video driver",
   165     Android_Available, Android_CreateDevice
   166 };
   167 
   168 
   169 int
   170 Android_VideoInit(_THIS)
   171 {
   172     SDL_DisplayMode mode;
   173 
   174     mode.format = Android_ScreenFormat;
   175     mode.w = Android_ScreenWidth;
   176     mode.h = Android_ScreenHeight;
   177     mode.refresh_rate = Android_ScreenRate;
   178     mode.driverdata = NULL;
   179     if (SDL_AddBasicVideoDisplay(&mode) < 0) {
   180         return -1;
   181     }
   182 
   183     SDL_AddDisplayMode(&_this->displays[0], &mode);
   184 
   185     Android_InitKeyboard();
   186 
   187     Android_InitTouch();
   188 
   189     Android_InitMouse();
   190 
   191     /* We're done! */
   192     return 0;
   193 }
   194 
   195 void
   196 Android_VideoQuit(_THIS)
   197 {
   198     Android_QuitTouch();
   199 }
   200 
   201 void
   202 Android_SetScreenResolution(int width, int height, Uint32 format, float rate)
   203 {
   204 	SDL_VideoDevice* device;
   205 	SDL_VideoDisplay *display;
   206     Android_ScreenWidth = width;
   207     Android_ScreenHeight = height;
   208     Android_ScreenFormat = format;
   209     Android_ScreenRate = rate;
   210 
   211     /*
   212       Update the resolution of the desktop mode, so that the window
   213       can be properly resized. The screen resolution change can for
   214       example happen when the Activity enters or exists immersive mode,
   215       which can happen after VideoInit().
   216     */
   217     device = SDL_GetVideoDevice();
   218     if (device && device->num_displays > 0)
   219     {
   220         display = &device->displays[0];
   221         display->desktop_mode.format = Android_ScreenFormat;
   222         display->desktop_mode.w = Android_ScreenWidth;
   223         display->desktop_mode.h = Android_ScreenHeight;
   224         display->desktop_mode.refresh_rate  = Android_ScreenRate;
   225     }
   226 
   227     if (Android_Window) {
   228         SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESIZED, width, height);
   229 
   230         /* Force the current mode to match the resize otherwise the SDL_WINDOWEVENT_RESTORED event
   231          * will fall back to the old mode */
   232         display = SDL_GetDisplayForWindow(Android_Window);
   233 
   234         display->current_mode.format = format;
   235         display->current_mode.w = width;
   236         display->current_mode.h = height;
   237         display->current_mode.refresh_rate = rate;
   238     }
   239 }
   240 
   241 #endif /* SDL_VIDEO_DRIVER_ANDROID */
   242 
   243 /* vi: set ts=4 sw=4 expandtab: */