dlls/wineandroid.drv/init.c

   1 /*
   2  * Android driver initialisation functions
   3  *
   4  * Copyright 1996, 2013, 2017 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #define NONAMELESSSTRUCT
  26 #define NONAMELESSUNION
  27 #include "config.h"
  28
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <dlfcn.h>
  32 #include <link.h>
  33
  34 #include "ntstatus.h"
  35 #define WIN32_NO_STATUS
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winreg.h"
  39 #include "android.h"
  40 #include "wine/server.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(android);
  44
  45 unsigned int screen_width = 0;
  46 unsigned int screen_height = 0;
  47 RECT virtual_screen_rect = { 0, 0, 0, 0 };
  48
  49 static const unsigned int screen_bpp = 32;  /* we don't support other modes */
  50
  51 static RECT monitor_rc_work;
  52 static int device_init_done;
  53 static BOOL force_display_devices_refresh;
  54
  55 PNTAPCFUNC register_window_callback;
  56
  57 typedef struct
  58 {
  59     struct gdi_physdev dev;
  60 } ANDROID_PDEVICE;
  61
  62 static const struct user_driver_funcs android_drv_funcs;
  63
  64
  65 /******************************************************************************
  66  *           init_monitors
  67  */
  68 void init_monitors( int width, int height )
  69 {
  70     static const WCHAR trayW[] = {'S','h','e','l','l','_','T','r','a','y','W','n','d',0};
  71     UNICODE_STRING name;
  72     RECT rect;
  73     HWND hwnd;
  74
  75     RtlInitUnicodeString( &name, trayW );
  76     hwnd = NtUserFindWindowEx( 0, 0, &name, NULL, 0 );
  77
  78     virtual_screen_rect.right = width;
  79     virtual_screen_rect.bottom = height;
  80     monitor_rc_work = virtual_screen_rect;
  81
  82     if (!hwnd || !NtUserIsWindowVisible( hwnd )) return;
  83     if (!NtUserGetWindowRect( hwnd, &rect )) return;
  84     if (rect.top) monitor_rc_work.bottom = rect.top;
  85     else monitor_rc_work.top = rect.bottom;
  86     TRACE( "found tray %p %s work area %s\n", hwnd,
  87            wine_dbgstr_rect( &rect ), wine_dbgstr_rect( &monitor_rc_work ));
  88
  89     if (*p_java_vm) /* if we're notified from Java thread, update registry */
  90     {
  91         UINT32 num_path, num_mode;
  92         force_display_devices_refresh = TRUE;
  93         /* trigger refresh in win32u */
  94         NtUserGetDisplayConfigBufferSizes( QDC_ONLY_ACTIVE_PATHS, &num_path, &num_mode );
  95     }
  96 }
  97
  98
  99 /* wrapper for NtCreateKey that creates the key recursively if necessary */
 100 static HKEY reg_create_key( const WCHAR *name, ULONG name_len )
 101 {
 102     UNICODE_STRING nameW = { name_len, name_len, (WCHAR *)name };
 103     OBJECT_ATTRIBUTES attr;
 104     NTSTATUS status;
 105     HANDLE ret;
 106
 107     attr.Length = sizeof(attr);
 108     attr.RootDirectory = 0;
 109     attr.ObjectName = &nameW;
 110     attr.Attributes = 0;
 111     attr.SecurityDescriptor = NULL;
 112     attr.SecurityQualityOfService = NULL;
 113
 114     status = NtCreateKey( &ret, MAXIMUM_ALLOWED, &attr, 0, NULL, 0, NULL );
 115     if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 116     {
 117         static const WCHAR registry_rootW[] = { '\\','R','e','g','i','s','t','r','y','\\' };
 118         DWORD pos = 0, i = 0, len = name_len / sizeof(WCHAR);
 119
 120         /* don't try to create registry root */
 121         if (len > ARRAY_SIZE(registry_rootW) &&
 122             !memcmp( name, registry_rootW, sizeof(registry_rootW) ))
 123             i += ARRAY_SIZE(registry_rootW);
 124
 125         while (i < len && name[i] != '\\') i++;
 126         if (i == len) return 0;
 127         for (;;)
 128         {
 129             nameW.Buffer = (WCHAR *)name + pos;
 130             nameW.Length = (i - pos) * sizeof(WCHAR);
 131             status = NtCreateKey( &ret, MAXIMUM_ALLOWED, &attr, 0, NULL, 0, NULL );
 132
 133             if (attr.RootDirectory) NtClose( attr.RootDirectory );
 134             if (status) return 0;
 135             if (i == len) break;
 136             attr.RootDirectory = ret;
 137             while (i < len && name[i] == '\\') i++;
 138             pos = i;
 139             while (i < len && name[i] != '\\') i++;
 140         }
 141     }
 142     return ret;
 143 }
 144
 145
 146 /******************************************************************************
 147  *           set_screen_dpi
 148  */
 149 void set_screen_dpi( DWORD dpi )
 150 {
 151     static const WCHAR dpi_value_name[] = {'L','o','g','P','i','x','e','l','s',0};
 152     static const WCHAR dpi_key_name[] =
 153     {
 154         '\\','R','e','g','i','s','t','r','y',
 155         '\\','M','a','c','h','i','n','e',
 156         '\\','S','y','s','t','e','m',
 157         '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
 158         '\\','H','a','r','d','w','a','r','e',' ','P','r','o','f','i','l','e','s',
 159         '\\','C','u','r','r','e','n','t',
 160         '\\','S','o','f','t','w','a','r','e',
 161         '\\','F','o','n','t','s'
 162     };
 163     HKEY hkey;
 164
 165     if ((hkey = reg_create_key( dpi_key_name, sizeof(dpi_key_name ))))
 166     {
 167         UNICODE_STRING name;
 168         RtlInitUnicodeString( &name, dpi_value_name );
 169         NtSetValueKey( hkey, &name, 0, REG_DWORD, &dpi, sizeof(dpi) );
 170         NtClose( hkey );
 171     }
 172 }
 173
 174 /**********************************************************************
 175  *           fetch_display_metrics
 176  */
 177 static void fetch_display_metrics(void)
 178 {
 179     if (*p_java_vm) return;  /* for Java threads it will be set when the top view is created */
 180
 181     SERVER_START_REQ( get_window_rectangles )
 182     {
 183         req->handle = wine_server_user_handle( NtUserGetDesktopWindow() );
 184         req->relative = COORDS_CLIENT;
 185         if (!wine_server_call( req ))
 186         {
 187             screen_width  = reply->window.right;
 188             screen_height = reply->window.bottom;
 189         }
 190     }
 191     SERVER_END_REQ;
 192
 193     init_monitors( screen_width, screen_height );
 194     TRACE( "screen %ux%u\n", screen_width, screen_height );
 195 }
 196
 197
 198 /**********************************************************************
 199  *           device_init
 200  *
 201  * Perform initializations needed upon creation of the first device.
 202  */
 203 static void device_init(void)
 204 {
 205     device_init_done = TRUE;
 206     fetch_display_metrics();
 207 }
 208
 209
 210 /******************************************************************************
 211  *           create_android_physdev
 212  */
 213 static ANDROID_PDEVICE *create_android_physdev(void)
 214 {
 215     ANDROID_PDEVICE *physdev;
 216
 217     if (!device_init_done) device_init();
 218
 219     if (!(physdev = calloc( 1, sizeof(*physdev) ))) return NULL;
 220     return physdev;
 221 }
 222
 223 /**********************************************************************
 224  *           ANDROID_CreateDC
 225  */
 226 static BOOL CDECL ANDROID_CreateDC( PHYSDEV *pdev, LPCWSTR device, LPCWSTR output,
 227                                     const DEVMODEW *initData )
 228 {
 229     ANDROID_PDEVICE *physdev = create_android_physdev();
 230
 231     if (!physdev) return FALSE;
 232
 233     push_dc_driver( pdev, &physdev->dev, &android_drv_funcs.dc_funcs );
 234     return TRUE;
 235 }
 236
 237
 238 /**********************************************************************
 239  *           ANDROID_CreateCompatibleDC
 240  */
 241 static BOOL CDECL ANDROID_CreateCompatibleDC( PHYSDEV orig, PHYSDEV *pdev )
 242 {
 243     ANDROID_PDEVICE *physdev = create_android_physdev();
 244
 245     if (!physdev) return FALSE;
 246
 247     push_dc_driver( pdev, &physdev->dev, &android_drv_funcs.dc_funcs );
 248     return TRUE;
 249 }
 250
 251
 252 /**********************************************************************
 253  *           ANDROID_DeleteDC
 254  */
 255 static BOOL CDECL ANDROID_DeleteDC( PHYSDEV dev )
 256 {
 257     free( dev );
 258     return TRUE;
 259 }
 260
 261
 262 /***********************************************************************
 263  *           ANDROID_ChangeDisplaySettings
 264  */
 265 LONG ANDROID_ChangeDisplaySettings( LPDEVMODEW displays, LPCWSTR primary_name, HWND hwnd, DWORD flags, LPVOID lpvoid )
 266 {
 267     FIXME( "(%p,%s,%p,0x%08x,%p)\n", displays, debugstr_w(primary_name), hwnd, (int)flags, lpvoid );
 268     return DISP_CHANGE_SUCCESSFUL;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           ANDROID_UpdateDisplayDevices
 274  */
 275 BOOL ANDROID_UpdateDisplayDevices( const struct gdi_device_manager *device_manager, BOOL force, void *param )
 276 {
 277     if (force || force_display_devices_refresh)
 278     {
 279         static const struct gdi_gpu gpu;
 280         static const struct gdi_adapter adapter =
 281         {
 282             .state_flags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE | DISPLAY_DEVICE_VGA_COMPATIBLE,
 283         };
 284         struct gdi_monitor gdi_monitor =
 285         {
 286             .rc_monitor = virtual_screen_rect,
 287             .rc_work = monitor_rc_work,
 288             .state_flags = DISPLAY_DEVICE_ACTIVE | DISPLAY_DEVICE_ATTACHED,
 289         };
 290         const DEVMODEW mode =
 291         {
 292             .dmFields = DM_DISPLAYORIENTATION | DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFLAGS | DM_DISPLAYFREQUENCY,
 293             .dmBitsPerPel = screen_bpp, .dmPelsWidth = screen_width, .dmPelsHeight = screen_height, .dmDisplayFrequency = 60,
 294         };
 295         device_manager->add_gpu( &gpu, param );
 296         device_manager->add_adapter( &adapter, param );
 297         device_manager->add_monitor( &gdi_monitor, param );
 298         device_manager->add_mode( &mode, param );
 299         force_display_devices_refresh = FALSE;
 300     }
 301
 302     return TRUE;
 303 }
 304
 305
 306 /***********************************************************************
 307  *           ANDROID_GetCurrentDisplaySettings
 308  */
 309 BOOL ANDROID_GetCurrentDisplaySettings( LPCWSTR name, BOOL is_primary, LPDEVMODEW devmode )
 310 {
 311     devmode->u2.dmDisplayFlags = 0;
 312     devmode->u1.s2.dmPosition.x = 0;
 313     devmode->u1.s2.dmPosition.y = 0;
 314     devmode->u1.s2.dmDisplayOrientation = 0;
 315     devmode->u1.s2.dmDisplayFixedOutput = 0;
 316     devmode->dmPelsWidth = screen_width;
 317     devmode->dmPelsHeight = screen_height;
 318     devmode->dmBitsPerPel = screen_bpp;
 319     devmode->dmDisplayFrequency = 60;
 320     devmode->dmFields = DM_POSITION | DM_DISPLAYORIENTATION | DM_PELSWIDTH | DM_PELSHEIGHT |
 321                         DM_BITSPERPEL | DM_DISPLAYFLAGS | DM_DISPLAYFREQUENCY;
 322     TRACE( "current mode -- %dx%d %d bpp @%d Hz\n",
 323            (int)devmode->dmPelsWidth, (int)devmode->dmPelsHeight,
 324            (int)devmode->dmBitsPerPel, (int)devmode->dmDisplayFrequency );
 325     return TRUE;
 326 }
 327
 328
 329 /**********************************************************************
 330  *           ANDROID_wine_get_wgl_driver
 331  */
 332 static struct opengl_funcs *ANDROID_wine_get_wgl_driver( UINT version )
 333 {
 334     return get_wgl_driver( version );
 335 }
 336
 337
 338 static const struct user_driver_funcs android_drv_funcs =
 339 {
 340     .dc_funcs.pCreateCompatibleDC = ANDROID_CreateCompatibleDC,
 341     .dc_funcs.pCreateDC = ANDROID_CreateDC,
 342     .dc_funcs.pDeleteDC = ANDROID_DeleteDC,
 343     .dc_funcs.priority = GDI_PRIORITY_GRAPHICS_DRV,
 344
 345     .pGetKeyNameText = ANDROID_GetKeyNameText,
 346     .pMapVirtualKeyEx = ANDROID_MapVirtualKeyEx,
 347     .pVkKeyScanEx = ANDROID_VkKeyScanEx,
 348     .pSetCursor = ANDROID_SetCursor,
 349     .pChangeDisplaySettings = ANDROID_ChangeDisplaySettings,
 350     .pGetCurrentDisplaySettings = ANDROID_GetCurrentDisplaySettings,
 351     .pUpdateDisplayDevices = ANDROID_UpdateDisplayDevices,
 352     .pCreateWindow = ANDROID_CreateWindow,
 353     .pDesktopWindowProc = ANDROID_DesktopWindowProc,
 354     .pDestroyWindow = ANDROID_DestroyWindow,
 355     .pProcessEvents = ANDROID_ProcessEvents,
 356     .pSetCapture = ANDROID_SetCapture,
 357     .pSetLayeredWindowAttributes = ANDROID_SetLayeredWindowAttributes,
 358     .pSetParent = ANDROID_SetParent,
 359     .pSetWindowRgn = ANDROID_SetWindowRgn,
 360     .pSetWindowStyle = ANDROID_SetWindowStyle,
 361     .pShowWindow = ANDROID_ShowWindow,
 362     .pUpdateLayeredWindow = ANDROID_UpdateLayeredWindow,
 363     .pWindowMessage = ANDROID_WindowMessage,
 364     .pWindowPosChanging = ANDROID_WindowPosChanging,
 365     .pWindowPosChanged = ANDROID_WindowPosChanged,
 366     .pwine_get_wgl_driver = ANDROID_wine_get_wgl_driver,
 367 };
 368
 369
 370 static const JNINativeMethod methods[] =
 371 {
 372     { "wine_desktop_changed", "(II)V", desktop_changed },
 373     { "wine_config_changed", "(I)V", config_changed },
 374     { "wine_surface_changed", "(ILandroid/view/Surface;Z)V", surface_changed },
 375     { "wine_motion_event", "(IIIIII)Z", motion_event },
 376     { "wine_keyboard_event", "(IIII)Z", keyboard_event },
 377 };
 378
 379 #define DECL_FUNCPTR(f) typeof(f) * p##f = NULL
 380 #define LOAD_FUNCPTR(lib, func) do { \
 381     if ((p##func = dlsym( lib, #func )) == NULL) \
 382         { ERR( "can't find symbol %s\n", #func); return; } \
 383     } while(0)
 384
 385 DECL_FUNCPTR( __android_log_print );
 386 DECL_FUNCPTR( ANativeWindow_fromSurface );
 387 DECL_FUNCPTR( ANativeWindow_release );
 388 DECL_FUNCPTR( hw_get_module );
 389
 390 #ifndef DT_GNU_HASH
 391 #define DT_GNU_HASH 0x6ffffef5
 392 #endif
 393
 394 static unsigned int gnu_hash( const char *name )
 395 {
 396     unsigned int h = 5381;
 397     while (*name) h = h * 33 + (unsigned char)*name++;
 398     return h;
 399 }
 400
 401 static unsigned int hash_symbol( const char *name )
 402 {
 403     unsigned int hi, hash = 0;
 404     while (*name)
 405     {
 406         hash = (hash << 4) + (unsigned char)*name++;
 407         hi = hash & 0xf0000000;
 408         hash ^= hi;
 409         hash ^= hi >> 24;
 410     }
 411     return hash;
 412 }
 413
 414 static void *find_symbol( const struct dl_phdr_info* info, const char *var, int type )
 415 {
 416     const ElfW(Dyn) *dyn = NULL;
 417     const ElfW(Phdr) *ph;
 418     const ElfW(Sym) *symtab = NULL;
 419     const Elf32_Word *hashtab = NULL;
 420     const Elf32_Word *gnu_hashtab = NULL;
 421     const char *strings = NULL;
 422     Elf32_Word idx;
 423
 424     for (ph = info->dlpi_phdr; ph < &info->dlpi_phdr[info->dlpi_phnum]; ++ph)
 425     {
 426         if (PT_DYNAMIC == ph->p_type)
 427         {
 428             dyn = (const ElfW(Dyn) *)(info->dlpi_addr + ph->p_vaddr);
 429             break;
 430         }
 431     }
 432     if (!dyn) return NULL;
 433
 434     while (dyn->d_tag)
 435     {
 436         if (dyn->d_tag == DT_STRTAB)
 437             strings = (const char*)(info->dlpi_addr + dyn->d_un.d_ptr);
 438         if (dyn->d_tag == DT_SYMTAB)
 439             symtab = (const ElfW(Sym) *)(info->dlpi_addr + dyn->d_un.d_ptr);
 440         if (dyn->d_tag == DT_HASH)
 441             hashtab = (const Elf32_Word *)(info->dlpi_addr + dyn->d_un.d_ptr);
 442         if (dyn->d_tag == DT_GNU_HASH)
 443             gnu_hashtab = (const Elf32_Word *)(info->dlpi_addr + dyn->d_un.d_ptr);
 444         dyn++;
 445     }
 446
 447     if (!symtab || !strings) return NULL;
 448
 449     if (gnu_hashtab)  /* new style hash table */
 450     {
 451         const unsigned int hash   = gnu_hash(var);
 452         const Elf32_Word nbuckets = gnu_hashtab[0];
 453         const Elf32_Word symbias  = gnu_hashtab[1];
 454         const Elf32_Word nwords   = gnu_hashtab[2];
 455         const ElfW(Addr) *bitmask = (const ElfW(Addr) *)(gnu_hashtab + 4);
 456         const Elf32_Word *buckets = (const Elf32_Word *)(bitmask + nwords);
 457         const Elf32_Word *chains  = buckets + nbuckets - symbias;
 458
 459         if (!(idx = buckets[hash % nbuckets])) return NULL;
 460         do
 461         {
 462             if ((chains[idx] & ~1u) == (hash & ~1u) &&
 463                 ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
 464                 ELF32_ST_TYPE(symtab[idx].st_info) == type &&
 465                 !strcmp( strings + symtab[idx].st_name, var ))
 466                 return (void *)(info->dlpi_addr + symtab[idx].st_value);
 467         } while (!(chains[idx++] & 1u));
 468     }
 469     else if (hashtab)  /* old style hash table */
 470     {
 471         const unsigned int hash   = hash_symbol( var );
 472         const Elf32_Word nbuckets = hashtab[0];
 473         const Elf32_Word *buckets = hashtab + 2;
 474         const Elf32_Word *chains  = buckets + nbuckets;
 475
 476         for (idx = buckets[hash % nbuckets]; idx; idx = chains[idx])
 477         {
 478             if (ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
 479                 ELF32_ST_TYPE(symtab[idx].st_info) == type &&
 480                 !strcmp( strings + symtab[idx].st_name, var ))
 481                 return (void *)(info->dlpi_addr + symtab[idx].st_value);
 482         }
 483     }
 484     return NULL;
 485 }
 486
 487 static int enum_libs( struct dl_phdr_info* info, size_t size, void* data )
 488 {
 489     const char *p;
 490
 491     if (!info->dlpi_name) return 0;
 492     if (!(p = strrchr( info->dlpi_name, '/' ))) return 0;
 493     if (strcmp( p, "/libhardware.so" )) return 0;
 494     TRACE( "found libhardware at %p\n", info->dlpi_phdr );
 495     phw_get_module = find_symbol( info, "hw_get_module", STT_FUNC );
 496     return 1;
 497 }
 498
 499 static void load_hardware_libs(void)
 500 {
 501     const struct hw_module_t *module;
 502     int ret;
 503     void *libhardware;
 504
 505     if ((libhardware = dlopen( "libhardware.so", RTLD_GLOBAL )))
 506     {
 507         LOAD_FUNCPTR( libhardware, hw_get_module );
 508     }
 509     else
 510     {
 511         /* Android >= N disallows loading libhardware, so we load libandroid (which imports
 512          * libhardware), and then we can find libhardware in the list of loaded libraries.
 513          */
 514         if (!dlopen( "libandroid.so", RTLD_GLOBAL ))
 515         {
 516             ERR( "failed to load libandroid.so: %s\n", dlerror() );
 517             return;
 518         }
 519         dl_iterate_phdr( enum_libs, 0 );
 520         if (!phw_get_module)
 521         {
 522             ERR( "failed to find hw_get_module\n" );
 523             return;
 524         }
 525     }
 526
 527     if ((ret = phw_get_module( GRALLOC_HARDWARE_MODULE_ID, &module )))
 528     {
 529         ERR( "failed to load gralloc module err %d\n", ret );
 530         return;
 531     }
 532
 533     init_gralloc( module );
 534 }
 535
 536 static void load_android_libs(void)
 537 {
 538     void *libandroid, *liblog;
 539
 540     if (!(libandroid = dlopen( "libandroid.so", RTLD_GLOBAL )))
 541     {
 542         ERR( "failed to load libandroid.so: %s\n", dlerror() );
 543         return;
 544     }
 545     if (!(liblog = dlopen( "liblog.so", RTLD_GLOBAL )))
 546     {
 547         ERR( "failed to load liblog.so: %s\n", dlerror() );
 548         return;
 549     }
 550     LOAD_FUNCPTR( liblog, __android_log_print );
 551     LOAD_FUNCPTR( libandroid, ANativeWindow_fromSurface );
 552     LOAD_FUNCPTR( libandroid, ANativeWindow_release );
 553 }
 554
 555 #undef DECL_FUNCPTR
 556 #undef LOAD_FUNCPTR
 557
 558 JavaVM **p_java_vm = NULL;
 559 jobject *p_java_object = NULL;
 560 unsigned short *p_java_gdt_sel = NULL;
 561
 562 static HRESULT android_init( void *arg )
 563 {
 564     struct init_params *params = arg;
 565     pthread_mutexattr_t attr;
 566     jclass class;
 567     jobject object;
 568     JNIEnv *jni_env;
 569     JavaVM *java_vm;
 570     void *ntdll;
 571
 572     if (!(ntdll = dlopen( "ntdll.so", RTLD_NOW ))) return STATUS_UNSUCCESSFUL;
 573
 574     p_java_vm = dlsym( ntdll, "java_vm" );
 575     p_java_object = dlsym( ntdll, "java_object" );
 576     p_java_gdt_sel = dlsym( ntdll, "java_gdt_sel" );
 577
 578     object = *p_java_object;
 579
 580     load_hardware_libs();
 581
 582     pthread_mutexattr_init( &attr );
 583     pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
 584     pthread_mutex_init( &drawable_mutex, &attr );
 585     pthread_mutex_init( &win_data_mutex, &attr );
 586     pthread_mutexattr_destroy( &attr );
 587
 588     register_window_callback = params->register_window_callback;
 589
 590     if ((java_vm = *p_java_vm))  /* running under Java */
 591     {
 592 #ifdef __i386__
 593         WORD old_fs;
 594         __asm__( "mov %%fs,%0" : "=r" (old_fs) );
 595 #endif
 596         load_android_libs();
 597         (*java_vm)->AttachCurrentThread( java_vm, &jni_env, 0 );
 598         class = (*jni_env)->GetObjectClass( jni_env, object );
 599         (*jni_env)->RegisterNatives( jni_env, class, methods, ARRAY_SIZE( methods ));
 600         (*jni_env)->DeleteLocalRef( jni_env, class );
 601 #ifdef __i386__
 602         /* the Java VM hijacks %fs for its own purposes, restore it */
 603         __asm__( "mov %0,%%fs" :: "r" (old_fs) );
 604 #endif
 605     }
 606     __wine_set_user_driver( &android_drv_funcs, WINE_GDI_DRIVER_VERSION );
 607     return STATUS_SUCCESS;
 608 }
 609
 610 const unixlib_entry_t __wine_unix_call_funcs[] =
 611 {
 612     android_create_desktop,
 613     android_dispatch_ioctl,
 614     android_init,
 615     android_java_init,
 616     android_java_uninit,
 617     android_register_window,
 618 };
 619
 620
 621 C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_funcs_count );