Debian Codegraph @

src/android/android_display.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * Android Java/JNI display driver
12 *
13 * By Thomas Fjellstrom.
14 *
15 */
16
17 #include "allegro5/allegro.h"
18 #include "allegro5/allegro_opengl.h"
19 #include "allegro5/internal/aintern_android.h"
20 #include "allegro5/internal/aintern_display.h"
21 #include "allegro5/internal/aintern_events.h"
22 #include "allegro5/internal/aintern_opengl.h"
23 #include "allegro5/internal/aintern_shader.h"
24 #include "allegro5/internal/aintern_pixels.h"
25
26 #include "EGL/egl.h"
27
28 ALLEGRO_DEBUG_CHANNEL("display")
29
30 static ALLEGRO_DISPLAY_INTERFACE *vt;
31 static ALLEGRO_EXTRA_DISPLAY_SETTINGS main_thread_display_settings;
32
33 static int select_best_visual_and_update(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d);
34 static void android_set_display_option(ALLEGRO_DISPLAY *d, int o, int v);
35 static void _al_android_resize_display(ALLEGRO_DISPLAY_ANDROID *d, int width, int height);
36 static bool _al_android_init_display(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *display);
37 void _al_android_clear_current(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d);
38 void _al_android_make_current(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d);
39
40 JNI_FUNC(void, AllegroSurface, nativeOnCreate, (JNIEnv *env, jobject obj))
41 {
42 ALLEGRO_DEBUG("nativeOnCreate");
43 (void)env;
44 (void)obj;
45
46 ALLEGRO_SYSTEM *system = (void *)al_get_system_driver();
47 ASSERT(system != NULL);
48
49 ALLEGRO_DEBUG("AllegroSurface_nativeOnCreate");
50
51 ALLEGRO_DISPLAY_ANDROID **dptr = _al_vector_ref(&system->displays, 0);
52 ALLEGRO_DISPLAY_ANDROID *d = *dptr;
53 ASSERT(d != NULL);
54
55 d->recreate = true;
56 }
57
58 JNI_FUNC(bool, AllegroSurface, nativeOnDestroy, (JNIEnv *env, jobject obj))
59 {
60 ALLEGRO_SYSTEM *sys = (void *)al_get_system_driver();
61 ASSERT(sys != NULL);
62
63 ALLEGRO_DISPLAY_ANDROID **dptr = _al_vector_ref(&sys->displays, 0);
64 ALLEGRO_DISPLAY_ANDROID *display = *dptr;
65 ASSERT(display != NULL);
66
67 ALLEGRO_DISPLAY *d = (ALLEGRO_DISPLAY *)display;
68
69 ALLEGRO_DEBUG("AllegroSurface_nativeOnDestroy");
70 (void)obj;
71 (void)env;
72
73 if (!display->created) {
74 ALLEGRO_DEBUG("Display creation failed, not sending HALT");
75 return false;
76 }
77
78 display->created = false;
79
80 if (display->is_destroy_display) {
81 return true;
82 }
83
84 // we'll wait for acknowledge_drawing_halt
85 display->halt_acknowledge = false;
86
87 // emit ALLEGRO_EVENT_DISPLAY_HALT_DRAWING
88 ALLEGRO_DEBUG("locking display event source: %p %p", d, &d->es);
89 _al_event_source_lock(&d->es);
90
91 if (_al_event_source_needs_to_generate_event(&d->es)) {
92 ALLEGRO_EVENT event;
93 event.display.type = ALLEGRO_EVENT_DISPLAY_HALT_DRAWING;
94 event.display.timestamp = al_current_time();
95 _al_event_source_emit_event(&d->es, &event);
96 }
97
98 ALLEGRO_DEBUG("unlocking display event source");
99 _al_event_source_unlock(&d->es);
100
101 // wait for acknowledge_drawing_halt
102 ALLEGRO_DEBUG("waiting for acknowledge_drawing_halt");
103 al_lock_mutex(display->mutex);
104 while (!display->halt_acknowledge)
105 al_wait_cond(display->cond, display->mutex);
106 al_unlock_mutex(display->mutex);
107 ALLEGRO_DEBUG("done waiting for acknowledge_drawing_halt");
108
109 ALLEGRO_DEBUG("AllegroSurface_nativeOnDestroy end");
110
111 return true;
112 }
113
114 // FIXME: need to loop over the display list looking for the right surface
115 // object in the following jni callbacks
116 JNI_FUNC(void, AllegroSurface, nativeOnChange, (JNIEnv *env, jobject obj,
117 jint format, jint width, jint height))
118 {
119 ALLEGRO_SYSTEM *system = (void *)al_get_system_driver();
120 ASSERT(system != NULL);
121
122 ALLEGRO_DISPLAY_ANDROID **dptr = _al_vector_ref(&system->displays, 0);
123 ALLEGRO_DISPLAY_ANDROID *d = *dptr;
124 ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY*)d;
125 ASSERT(display != NULL);
126
127 ALLEGRO_DEBUG("on change %dx%d!", width, height);
128 (void)format;
129
130 if (!d->first_run && !d->recreate) {
131 _al_android_resize_display(d, width, height);
132 return;
133 }
134
135 al_lock_mutex(d->mutex);
136
137 if (d->first_run || d->recreate) {
138 d->surface_object = (*env)->NewGlobalRef(env, obj);
139 if (display->flags & ALLEGRO_FULLSCREEN_WINDOW) {
140 display->w = width;
141 display->h = height;
142 }
143 }
144
145 bool ret = _al_android_init_display(env, d);
146 if (!ret && d->first_run) {
147 al_broadcast_cond(d->cond);
148 al_unlock_mutex(d->mutex);
149 return;
150 }
151
152 _al_android_clear_current(env, d);
153
154 d->created = true;
155 d->recreate = false;
156 d->resumed = false;
157
158 if (!d->first_run) {
159 ALLEGRO_DEBUG("locking display event source: %p", d);
160 _al_event_source_lock(&display->es);
161
162 ALLEGRO_DEBUG("check generate event");
163 if (_al_event_source_needs_to_generate_event(&display->es)) {
164 ALLEGRO_EVENT event;
165 event.display.type = ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING;
166 event.display.timestamp = al_current_time();
167 _al_event_source_emit_event(&display->es, &event);
168 }
169
170 ALLEGRO_DEBUG("unlocking display event source");
171 _al_event_source_unlock(&display->es);
172 }
173
174 if (d->first_run) {
175 al_broadcast_cond(d->cond);
176 d->first_run = false;
177 }
178 else {
179 ALLEGRO_DEBUG("Waiting for al_acknowledge_drawing_resume");
180 while (!d->resumed) {
181 al_wait_cond(d->cond, d->mutex);
182 }
183 ALLEGRO_DEBUG("Got al_acknowledge_drawing_resume");
184 }
185
186 al_unlock_mutex(d->mutex);
187
188 /* Send a resize event to signify that the display may have changed sizes. */
189 if (!d->first_run) {
190 _al_android_resize_display(d, width, height);
191 }
192 }
193
194 JNI_FUNC(void, AllegroSurface, nativeOnJoystickAxis, (JNIEnv *env, jobject obj,
195 jint index, jint stick, jint axis, jfloat value))
196 {
197 (void)env;
198 (void)obj;
199 _al_android_generate_joystick_axis_event(index+1, stick, axis, value);
200 }
201
202 JNI_FUNC(void, AllegroSurface, nativeOnJoystickButton, (JNIEnv *env, jobject obj,
203 jint index, jint button, jboolean down))
204 {
205 (void)env;
206 (void)obj;
207 _al_android_generate_joystick_button_event(index+1, button, down);
208 }
209
210 void _al_android_create_surface(JNIEnv *env, bool post)
211 {
212 if (post) {
213 _jni_callVoidMethod(env, _al_android_activity_object(),
214 "postCreateSurface");
215 }
216 else {
217 _jni_callVoidMethod(env, _al_android_activity_object(),
218 "createSurface");
219 }
220 }
221
222 void _al_android_destroy_surface(JNIEnv *env, jobject surface, bool post)
223 {
224 (void)surface;
225 if (post) {
226 _jni_callVoidMethodV(env, _al_android_activity_object(),
227 "postDestroySurface", "()V");
228 }
229 else {
230 _jni_callVoidMethodV(env, _al_android_activity_object(),
231 "destroySurface", "()V");
232 }
233 }
234
235 void _al_android_make_current(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d)
236 {
237 _jni_callVoidMethodV(env, d->surface_object, "egl_makeCurrent", "()V");
238 }
239
240 void _al_android_clear_current(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d)
241 {
242 _jni_callVoidMethodV(env, d->surface_object, "egl_clearCurrent", "()V");
243 }
244
245 static bool _al_android_init_display(JNIEnv *env,
246 ALLEGRO_DISPLAY_ANDROID *display)
247 {
248 ALLEGRO_SYSTEM_ANDROID *system = (void *)al_get_system_driver();
249 ALLEGRO_DISPLAY *d = (ALLEGRO_DISPLAY *)display;
250 const ALLEGRO_EXTRA_DISPLAY_SETTINGS *extras = &main_thread_display_settings;
251 int config_index;
252 bool programmable_pipeline;
253 int major_version, minor_version;
254 bool is_required_major, is_required_minor;
255 bool is_suggested_major, is_suggested_minor;
256 int ret;
257
258 ASSERT(system != NULL);
259 ASSERT(display != NULL);
260
261 ALLEGRO_DEBUG("calling egl_Init");
262
263 if (!_jni_callBooleanMethodV(env, display->surface_object,
264 "egl_Init", "()Z"))
265 {
266 // XXX should probably destroy the AllegroSurface here
267 ALLEGRO_ERROR("failed to initialize EGL");
268 display->failed = true;
269 return false;
270 }
271
272 config_index = select_best_visual_and_update(env, display);
273 if (config_index < 0) {
274 // XXX should probably destroy the AllegroSurface here
275 ALLEGRO_ERROR("Failed to choose config.\n");
276 display->failed = true;
277 return false;
278 }
279
280 programmable_pipeline = (d->flags & ALLEGRO_PROGRAMMABLE_PIPELINE);
281 major_version = extras->settings[ALLEGRO_OPENGL_MAJOR_VERSION];
282 minor_version = extras->settings[ALLEGRO_OPENGL_MINOR_VERSION];
283 is_required_major = (extras->required & ((int64_t)1 << ALLEGRO_OPENGL_MAJOR_VERSION));
284 is_required_minor = (extras->required & ((int64_t)1 << ALLEGRO_OPENGL_MINOR_VERSION));
285 is_suggested_major = (extras->suggested & ((int64_t)1 << ALLEGRO_OPENGL_MAJOR_VERSION));
286 is_suggested_minor = (extras->suggested & ((int64_t)1 << ALLEGRO_OPENGL_MINOR_VERSION));
287
288 if (!is_required_major && !is_suggested_major) // "don't care"
289 major_version = 0;
290 if (!is_required_minor && !is_suggested_minor)
291 minor_version = 0;
292
293 ALLEGRO_DEBUG("calling egl_createContext");
294 ret = _jni_callIntMethodV(env, display->surface_object,
295 "egl_createContext", "(IZIIZZ)I", config_index, programmable_pipeline,
296 major_version, minor_version, is_required_major, is_required_minor);
297 if (!ret) {
298 // XXX should probably destroy the AllegroSurface here
299 ALLEGRO_ERROR("failed to create egl context!");
300 display->failed = true;
301 return false;
302 }
303
304 ALLEGRO_DEBUG("calling egl_createSurface");
305 if (!_jni_callBooleanMethodV(env, display->surface_object,
306 "egl_createSurface", "()Z"))
307 {
308 // XXX should probably destroy the AllegroSurface here
309 ALLEGRO_ERROR("failed to create egl surface!");
310 display->failed = true;
311 return false;
312 }
313
314 ALLEGRO_DEBUG("initialize ogl extensions");
315 _al_ogl_manage_extensions(d);
316 _al_ogl_set_extensions(d->ogl_extras->extension_api);
317
318 _al_ogl_setup_gl(d);
319
320 return true;
321 }
322
323
324 /* implementation helpers */
325
326 static void _al_android_resize_display(ALLEGRO_DISPLAY_ANDROID *d,
327 int width, int height)
328 {
329 ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)d;
330 bool emitted_event = true;
331
332 ALLEGRO_DEBUG("display resize");
333
334 d->resize_acknowledge = false;
335 d->resize_acknowledge2 = false;
336
337 ALLEGRO_DEBUG("locking mutex");
338 al_lock_mutex(d->mutex);
339 ALLEGRO_DEBUG("done locking mutex");
340
341 ALLEGRO_DEBUG("locking display event source: %p", d);
342 _al_event_source_lock(&display->es);
343
344 ALLEGRO_DEBUG("check generate event");
345 if(_al_event_source_needs_to_generate_event(&display->es)) {
346 ALLEGRO_EVENT event;
347 event.display.type = ALLEGRO_EVENT_DISPLAY_RESIZE;
348 event.display.timestamp = al_current_time();
349 event.display.x = 0; // FIXME: probably not correct
350 event.display.y = 0;
351 event.display.width = width;
352 event.display.height = height;
353 event.display.orientation = _al_android_get_display_orientation();
354 _al_event_source_emit_event(&display->es, &event);
355 }
356 else {
357 emitted_event = false;
358 }
359
360 ALLEGRO_DEBUG("unlocking display event source");
361 _al_event_source_unlock(&display->es);
362
363 if (emitted_event) {
364 ALLEGRO_DEBUG("waiting for display resize acknowledge");
365 while (!d->resize_acknowledge) {
366 ALLEGRO_DEBUG("calling al_wait_cond");
367 al_wait_cond(d->cond, d->mutex);
368 }
369 al_unlock_mutex(d->mutex);
370 ALLEGRO_DEBUG("done waiting for display resize acknowledge");
371 }
372
373 display->w = width;
374 display->h = height;
375
376 ALLEGRO_DEBUG("resize backbuffer");
377 _al_ogl_setup_gl(display);
378
379 if (emitted_event) {
380 d->resize_acknowledge2 = true;
381 al_broadcast_cond(d->cond);
382 }
383
384 al_unlock_mutex(d->mutex);
385
386 ALLEGRO_DEBUG("done");
387 }
388
389 static void call_initRequiredAttribs(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d)
390 {
391 _jni_callVoidMethodV(env, d->surface_object,
392 "egl_initRequiredAttribs", "()V");
393 }
394
395 static void call_setRequiredAttrib(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d,
396 int attr, int value)
397 {
398 _jni_callVoidMethodV(env, d->surface_object,
399 "egl_setRequiredAttrib", "(II)V", attr, value);
400 }
401
402 static int call_chooseConfig(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d)
403 {
404 bool pp = (d->display.flags & ALLEGRO_PROGRAMMABLE_PIPELINE);
405 return _jni_callIntMethodV(env, d->surface_object,
406 "egl_chooseConfig", "(Z)I", pp);
407 }
408
409 static void call_getConfigAttribs(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d,
410 int configIndex, ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds)
411 {
412 jintArray jArray;
413 jint *ptr;
414 int i;
415
416 jArray = (*env)->NewIntArray(env, ALLEGRO_DISPLAY_OPTIONS_COUNT);
417 if (jArray == NULL) {
418 ALLEGRO_ERROR("NewIntArray failed\n");
419 return;
420 }
421
422 _jni_callVoidMethodV(env, d->surface_object,
423 "egl_getConfigAttribs", "(I[I)V", configIndex, jArray);
424
425 ptr = (*env)->GetIntArrayElements(env, jArray, 0);
426 for (i = 0; i < ALLEGRO_DISPLAY_OPTIONS_COUNT; i++) {
427 eds->settings[i] = ptr[i];
428 }
429
430 (*env)->ReleaseIntArrayElements(env, jArray, ptr, 0);
431 }
432
433 static void set_required_attribs(JNIEnv *env, ALLEGRO_DISPLAY_ANDROID *d,
434 ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref)
435 {
436 #define MAYBE_SET(v) \
437 do { \
438 bool required = (ref->required & ((int64_t)1 << (v))); \
439 if (required) { \
440 call_setRequiredAttrib(env, d, (v), ref->settings[(v)]); \
441 } \
442 } while (0)
443
444 MAYBE_SET(ALLEGRO_RED_SIZE);
445 MAYBE_SET(ALLEGRO_GREEN_SIZE);
446 MAYBE_SET(ALLEGRO_BLUE_SIZE);
447 MAYBE_SET(ALLEGRO_ALPHA_SIZE);
448 MAYBE_SET(ALLEGRO_COLOR_SIZE);
449 MAYBE_SET(ALLEGRO_DEPTH_SIZE);
450 MAYBE_SET(ALLEGRO_STENCIL_SIZE);
451 MAYBE_SET(ALLEGRO_SAMPLE_BUFFERS);
452 MAYBE_SET(ALLEGRO_SAMPLES);
453
454 #undef MAYBE_SET
455 }
456
457 static int select_best_visual_and_update(JNIEnv *env,
458 ALLEGRO_DISPLAY_ANDROID *d)
459 {
460 ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref = &main_thread_display_settings;
461 ALLEGRO_EXTRA_DISPLAY_SETTINGS **eds = NULL;
462 int num_configs;
463 int chosen_index;
464 int i;
465
466 ALLEGRO_DEBUG("Setting required display settings.\n");
467 call_initRequiredAttribs(env, d);
468 set_required_attribs(env, d, ref);
469
470 ALLEGRO_DEBUG("Calling eglChooseConfig.\n");
471 num_configs = call_chooseConfig(env, d);
472 if (num_configs < 1) {
473 return -1;
474 }
475
476 eds = al_calloc(num_configs, sizeof(*eds));
477
478 for (i = 0; i < num_configs; i++) {
479 eds[i] = al_calloc(1, sizeof(*eds[i]));
480
481 call_getConfigAttribs(env, d, i, eds[i]);
482
483 eds[i]->settings[ALLEGRO_RENDER_METHOD] = 1;
484 eds[i]->settings[ALLEGRO_COMPATIBLE_DISPLAY] = 1;
485 eds[i]->settings[ALLEGRO_SWAP_METHOD] = 2;
486 eds[i]->settings[ALLEGRO_VSYNC] = 1;
487
488 eds[i]->index = i;
489 eds[i]->score = _al_score_display_settings(eds[i], ref);
490 }
491
492 ALLEGRO_DEBUG("Sorting configs.\n");
493 qsort(eds, num_configs, sizeof(*eds), _al_display_settings_sorter);
494
495 chosen_index = eds[0]->index;
496 ALLEGRO_INFO("Chose config %i\n", chosen_index);
497
498 d->display.extra_settings = *eds[0];
499
500 /* Don't need this any more. */
501 for (i = 0; i < num_configs; i++) {
502 al_free(eds[i]);
503 }
504 al_free(eds);
505
506 return chosen_index;
507 }
508
509 /* driver implementation hooks */
510
511 static bool android_set_display_flag(ALLEGRO_DISPLAY *dpy, int flag, bool onoff)
512 {
513 (void)dpy; (void)flag; (void)onoff;
514
515 if (flag == ALLEGRO_FRAMELESS) {
516 _jni_callVoidMethodV(_al_android_get_jnienv(),
517 _al_android_activity_object(), "setAllegroFrameless", "(Z)V", onoff);
518 }
519
520 return false;
521 }
522
523 static ALLEGRO_DISPLAY *android_create_display(int w, int h)
524 {
525 ALLEGRO_DEBUG("begin");
526
527 int flags = al_get_new_display_flags();
528 #ifndef ALLEGRO_CFG_OPENGL_PROGRAMMABLE_PIPELINE
529 if (flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
530 ALLEGRO_WARN("Programmable pipeline support not built.\n");
531 return NULL;
532 }
533 #endif
534
535 ALLEGRO_DISPLAY_ANDROID *d = al_malloc(sizeof *d);
536 ALLEGRO_DISPLAY *display = (void *)d;
537
538 ALLEGRO_OGL_EXTRAS *ogl = al_malloc(sizeof *ogl);
539 memset(d, 0, sizeof *d);
540 memset(ogl, 0, sizeof *ogl);
541 display->ogl_extras = ogl;
542 display->vt = _al_get_android_display_driver();
543 display->w = w;
544 display->h = h;
545 display->flags = flags;
546
547 display->flags |= ALLEGRO_OPENGL;
548 #ifdef ALLEGRO_CFG_OPENGLES2
549 display->flags |= ALLEGRO_PROGRAMMABLE_PIPELINE;
550 #endif
551 #ifdef ALLEGRO_CFG_OPENGLES
552 display->flags |= ALLEGRO_OPENGL_ES_PROFILE;
553 #endif
554
555 _al_event_source_init(&display->es);
556
557 /* Java thread needs this but it's thread local.
558 * For now we assume display is created and set up in main thread.
559 */
560 main_thread_display_settings = *_al_get_new_display_settings();
561
562 d->mutex = al_create_mutex();
563 d->cond = al_create_cond();
564 d->recreate = true;
565 d->first_run = true;
566 d->failed = false;
567
568 ALLEGRO_SYSTEM *system = (void *)al_get_system_driver();
569 ASSERT(system != NULL);
570
571 ALLEGRO_DISPLAY_ANDROID **add;
572 add = _al_vector_alloc_back(&system->displays);
573 *add = d;
574
575 al_lock_mutex(d->mutex);
576
577 // post create surface request and wait
578 _al_android_create_surface(_al_android_get_jnienv(), true);
579
580 // wait for sizing to happen
581 ALLEGRO_DEBUG("waiting for surface onChange");
582 while (!d->created && !d->failed) {
583 al_wait_cond(d->cond, d->mutex);
584 }
585 al_unlock_mutex(d->mutex);
586 ALLEGRO_DEBUG("done waiting for surface onChange");
587
588 if (d->failed) {
589 ALLEGRO_DEBUG("Display creation failed");
590 _al_vector_find_and_delete(&system->displays, &d);
591 al_free(ogl);
592 al_free(d);
593 return NULL;
594 }
595
596 ALLEGRO_DEBUG("display: %p %ix%i", display, display->w, display->h);
597
598 _al_android_clear_current(_al_android_get_jnienv(), d);
599 _al_android_make_current(_al_android_get_jnienv(), d);
600
601 /* Don't need to repeat what this does */
602 android_set_display_option(display, ALLEGRO_SUPPORTED_ORIENTATIONS,
603 al_get_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS, NULL));
604
605 /* Fill in opengl version */
606 const int v = d->display.ogl_extras->ogl_info.version;
607 d->display.extra_settings.settings[ALLEGRO_OPENGL_MAJOR_VERSION] = (v >> 24) & 0xFF;
608 d->display.extra_settings.settings[ALLEGRO_OPENGL_MINOR_VERSION] = (v >> 16) & 0xFF;
609
610 if (flags & ALLEGRO_FRAMELESS) {
611 android_set_display_flag(display, ALLEGRO_FRAMELESS, true);
612 }
613
614 ALLEGRO_DEBUG("end");
615 return display;
616 }
617
618 static void android_destroy_display(ALLEGRO_DISPLAY *dpy)
619 {
620 ALLEGRO_DISPLAY_ANDROID *d = (ALLEGRO_DISPLAY_ANDROID*)dpy;
621
622 ALLEGRO_DEBUG("clear current");
623
624 if (!d->created) {
625 // if nativeOnDestroy was called (the app switched out) and
626 // then the display is destroyed before the app switches back
627 // in, there is no EGL context to destroy.
628 goto already_deleted;
629 }
630
631 _al_android_clear_current(_al_android_get_jnienv(), d);
632
633 al_lock_mutex(d->mutex);
634
635 d->is_destroy_display = true;
636
637 _al_android_destroy_surface(_al_android_get_jnienv(), d, true);
638
639 /* I don't think we can use a condition for this, because there are two
640 * possibilities of how a nativeOnDestroy/surfaceDestroyed callback can be
641 * called. One is from here, manually, and one happens automatically and is
642 * out of our hands.
643 */
644 while (d->created) {
645 al_rest(0.001);
646 }
647
648 _al_event_source_free(&dpy->es);
649
650 already_deleted:
651 // XXX: this causes a crash, no idea why as of yet
652 //ALLEGRO_DEBUG("destroy backbuffer");
653 //_al_ogl_destroy_backbuffer(al_get_backbuffer(dpy));
654
655 ALLEGRO_DEBUG("destroy mutex");
656 al_destroy_mutex(d->mutex);
657
658 ALLEGRO_DEBUG("destroy cond");
659 al_destroy_cond(d->cond);
660
661 ALLEGRO_DEBUG("free ogl_extras");
662 al_free(dpy->ogl_extras);
663
664 ALLEGRO_DEBUG("remove display from system list");
665 ALLEGRO_SYSTEM *s = al_get_system_driver();
666 _al_vector_find_and_delete(&s->displays, &d);
667
668 _al_vector_free(&dpy->bitmaps);
669 al_free(dpy->vertex_cache);
670
671 ALLEGRO_DEBUG("free display");
672 al_free(d);
673
674 ALLEGRO_DEBUG("done");
675 }
676
677 static bool android_set_current_display(ALLEGRO_DISPLAY *dpy)
678 {
679 ALLEGRO_DEBUG("make current %p", dpy);
680
681 if (al_get_current_display() != NULL){
682 _al_android_clear_current(_al_android_get_jnienv(),
683 (ALLEGRO_DISPLAY_ANDROID *)al_get_current_display());
684 }
685
686 if (dpy) {
687 _al_android_make_current(_al_android_get_jnienv(),
688 (ALLEGRO_DISPLAY_ANDROID *)dpy);
689 }
690
691 _al_ogl_update_render_state(dpy);
692
693 return true;
694 }
695
696 static void android_unset_current_display(ALLEGRO_DISPLAY *dpy)
697 {
698 ALLEGRO_DEBUG("unset current %p", dpy);
699 _al_android_clear_current(_al_android_get_jnienv(),
700 (ALLEGRO_DISPLAY_ANDROID *)dpy);
701 }
702
703 static void android_flip_display(ALLEGRO_DISPLAY *dpy)
704 {
705 // Some Androids crash if you swap buffers with an fbo bound
706 // so temporarily change target to the backbuffer.
707 ALLEGRO_BITMAP *old_target = al_get_target_bitmap();
708 al_set_target_backbuffer(dpy);
709
710 _jni_callVoidMethod(_al_android_get_jnienv(),
711 ((ALLEGRO_DISPLAY_ANDROID *)dpy)->surface_object, "egl_SwapBuffers");
712
713 al_set_target_bitmap(old_target);
714
715 /* Backup bitmaps created without ALLEGRO_NO_PRESERVE_TEXTURE that are
716 * dirty, to system memory.
717 */
718 al_backup_dirty_bitmaps(dpy);
719 }
720
721 static void android_update_display_region(ALLEGRO_DISPLAY *dpy, int x, int y,
722 int width, int height)
723 {
724 (void)x;
725 (void)y;
726 (void)width;
727 (void)height;
728 android_flip_display(dpy);
729 }
730
731 static bool android_acknowledge_resize(ALLEGRO_DISPLAY *dpy)
732 {
733 ALLEGRO_DISPLAY_ANDROID *d = (ALLEGRO_DISPLAY_ANDROID *)dpy;
734
735 ALLEGRO_DEBUG("clear current context");
736 _al_android_clear_current(_al_android_get_jnienv(), d);
737
738 ALLEGRO_DEBUG("locking mutex");
739 al_lock_mutex(d->mutex);
740 d->resize_acknowledge = true;
741 al_broadcast_cond(d->cond);
742 ALLEGRO_DEBUG("broadcasted condvar");
743
744 ALLEGRO_DEBUG("waiting for display resize acknowledge 2");
745 while (!d->resize_acknowledge2) {
746 ALLEGRO_DEBUG("calling al_wait_cond");
747 al_wait_cond(d->cond, d->mutex);
748 }
749 al_unlock_mutex(d->mutex);
750 ALLEGRO_DEBUG("done waiting for display resize acknowledge 2");
751
752 ALLEGRO_DEBUG("acquire context");
753 _al_android_make_current(_al_android_get_jnienv(), d);
754
755 ALLEGRO_DEBUG("done");
756 return true;
757 }
758
759 static int android_get_orientation(ALLEGRO_DISPLAY *dpy)
760 {
761 (void)dpy;
762 return _al_android_get_display_orientation();
763 }
764
765 static bool android_is_compatible_bitmap(ALLEGRO_DISPLAY *dpy,
766 ALLEGRO_BITMAP *bmp)
767 {
768 (void)dpy;
769 (void)bmp;
770 return true;
771 }
772
773 static bool android_resize_display(ALLEGRO_DISPLAY *dpy, int w, int h)
774 {
775 (void)dpy;
776 (void)w;
777 (void)h;
778 return false;
779 }
780
781 static void android_set_icons(ALLEGRO_DISPLAY *dpy, int num_icons,
782 ALLEGRO_BITMAP *bmps[])
783 {
784 (void)dpy;
785 (void)num_icons;
786 (void)bmps;
787 }
788
789 static void android_set_window_title(ALLEGRO_DISPLAY *dpy, const char *title)
790 {
791 (void)dpy; (void)title;
792 }
793
794 static void android_set_window_position(ALLEGRO_DISPLAY *dpy, int x, int y)
795 {
796 (void)dpy;
797 (void)x;
798 (void)y;
799 }
800
801 static void android_get_window_position(ALLEGRO_DISPLAY *dpy, int *x, int *y)
802 {
803 (void)dpy;
804 *x = *y = 0;
805 }
806
807 static bool android_wait_for_vsync(ALLEGRO_DISPLAY *dpy)
808 {
809 (void)dpy;
810 return false;
811 }
812
813 static bool android_set_mouse_cursor(ALLEGRO_DISPLAY *dpy,
814 ALLEGRO_MOUSE_CURSOR *cursor)
815 {
816 (void)dpy; (void)cursor;
817 return false;
818 }
819
820 static bool android_set_system_mouse_cursor(ALLEGRO_DISPLAY *dpy,
821 ALLEGRO_SYSTEM_MOUSE_CURSOR id)
822 {
823 (void)dpy; (void)id;
824 return false;
825 }
826
827 static bool android_show_mouse_cursor(ALLEGRO_DISPLAY *dpy)
828 {
829 (void)dpy;
830 return false;
831 }
832
833 static bool android_hide_mouse_cursor(ALLEGRO_DISPLAY *dpy)
834 {
835 (void)dpy;
836 return false;
837 }
838
839 static void android_acknowledge_drawing_halt(ALLEGRO_DISPLAY *dpy)
840 {
841 int i;
842 ALLEGRO_DEBUG("android_acknowledge_drawing_halt");
843
844 for (i = 0; i < (int)dpy->bitmaps._size; i++) {
845 ALLEGRO_BITMAP **bptr = _al_vector_ref(&dpy->bitmaps, i);
846 ALLEGRO_BITMAP *bmp = *bptr;
847 int bitmap_flags = al_get_bitmap_flags(bmp);
848
849 if (!bmp->parent &&
850 !(bitmap_flags & ALLEGRO_MEMORY_BITMAP))
851 {
852 ALLEGRO_BITMAP_EXTRA_OPENGL *extra = bmp->extra;
853 al_remove_opengl_fbo(bmp);
854 glDeleteTextures(1, &extra->texture);
855 extra->texture = 0;
856 }
857 }
858
859 ALLEGRO_DISPLAY_ANDROID *d = (ALLEGRO_DISPLAY_ANDROID *)dpy;
860
861 _al_android_clear_current(_al_android_get_jnienv(), d);
862
863 /* signal the condition variable */
864 al_lock_mutex(d->mutex);
865 d->halt_acknowledge = true;
866 al_broadcast_cond(d->cond);
867 al_unlock_mutex(d->mutex);
868
869 ALLEGRO_DEBUG("acknowledged drawing halt");
870 }
871
872 static void android_broadcast_resume(ALLEGRO_DISPLAY_ANDROID *d)
873 {
874 ALLEGRO_DEBUG("Broadcasting resume");
875 d->resumed = true;
876 al_broadcast_cond(d->cond);
877 ALLEGRO_DEBUG("done broadcasting resume");
878 }
879
880 static void android_acknowledge_drawing_resume(ALLEGRO_DISPLAY *dpy)
881 {
882 unsigned i;
883
884 ALLEGRO_DEBUG("begin");
885
886 ALLEGRO_DISPLAY_ANDROID *d = (ALLEGRO_DISPLAY_ANDROID *)dpy;
887
888 _al_android_clear_current(_al_android_get_jnienv(), d);
889 _al_android_make_current(_al_android_get_jnienv(), d);
890
891 ALLEGRO_DEBUG("made current");
892
893 if (dpy->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
894 dpy->default_shader = _al_create_default_shader(dpy);
895 }
896
897 // Bitmaps can still have stale shaders attached.
898 _al_glsl_unuse_shaders();
899
900 // Restore the transformations.
901 dpy->vt->update_transformation(dpy, al_get_target_bitmap());
902
903 // Restore bitmaps
904 // have to get this because new bitmaps could be created below
905 for (i = 0; i < _al_vector_size(&dpy->bitmaps); i++) {
906 ALLEGRO_BITMAP **bptr = _al_vector_ref(&dpy->bitmaps, i);
907 ALLEGRO_BITMAP *bmp = *bptr;
908 int bitmap_flags = al_get_bitmap_flags(bmp);
909
910 if (!bmp->parent &&
911 !(bitmap_flags & ALLEGRO_MEMORY_BITMAP))
912 {
913 int format = al_get_bitmap_format(bmp);
914 format = _al_pixel_format_is_compressed(format) ? ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE : format;
915
916 if (!(bitmap_flags & ALLEGRO_NO_PRESERVE_TEXTURE))
917 _al_ogl_upload_bitmap_memory(bmp, format, bmp->memory);
918 else
919 _al_ogl_upload_bitmap_memory(bmp, format, NULL);
920
921 bmp->dirty = false;
922 }
923 }
924
925 android_broadcast_resume(d);
926
927 ALLEGRO_DEBUG("acknowledge_drawing_resume end");
928 }
929
930 static void android_set_display_option(ALLEGRO_DISPLAY *d, int o, int v)
931 {
932 (void)d;
933
934 if (o == ALLEGRO_SUPPORTED_ORIENTATIONS) {
935 _jni_callVoidMethodV(_al_android_get_jnienv(),
936 _al_android_activity_object(), "setAllegroOrientation", "(I)V", v);
937 }
938 }
939
940 /* obtain a reference to the android driver */
941 ALLEGRO_DISPLAY_INTERFACE *_al_get_android_display_driver(void)
942 {
943 if (vt)
944 return vt;
945
946 vt = al_malloc(sizeof *vt);
947 memset(vt, 0, sizeof *vt);
948
949 vt->create_display = android_create_display;
950 vt->destroy_display = android_destroy_display;
951 vt->set_current_display = android_set_current_display;
952 vt->unset_current_display = android_unset_current_display;
953 vt->flip_display = android_flip_display;
954 vt->update_display_region = android_update_display_region;
955 vt->acknowledge_resize = android_acknowledge_resize;
956 vt->create_bitmap = _al_ogl_create_bitmap;
957 vt->get_backbuffer = _al_ogl_get_backbuffer;
958 vt->set_target_bitmap = _al_ogl_set_target_bitmap;
959
960 vt->get_orientation = android_get_orientation;
961
962 vt->is_compatible_bitmap = android_is_compatible_bitmap;
963 vt->resize_display = android_resize_display;
964 vt->set_icons = android_set_icons;
965 vt->set_window_title = android_set_window_title;
966 vt->set_window_position = android_set_window_position;
967 vt->get_window_position = android_get_window_position;
968 vt->set_display_flag = android_set_display_flag;
969 vt->wait_for_vsync = android_wait_for_vsync;
970
971 vt->set_mouse_cursor = android_set_mouse_cursor;
972 vt->set_system_mouse_cursor = android_set_system_mouse_cursor;
973 vt->show_mouse_cursor = android_show_mouse_cursor;
974 vt->hide_mouse_cursor = android_hide_mouse_cursor;
975
976 vt->acknowledge_drawing_halt = android_acknowledge_drawing_halt;
977 vt->acknowledge_drawing_resume = android_acknowledge_drawing_resume;
978
979 vt->set_display_option = android_set_display_option;
980
981 vt->update_render_state = _al_ogl_update_render_state;
982
983 _al_ogl_add_drawing_functions(vt);
984 _al_android_add_clipboard_functions(vt);
985
986 return vt;
987 }
988
989 /* vim: set sts=3 sw=3 et: */