Android: Rotation issues and Soft keys

alehbeer

Two questions:

I am running now on a real Nexus7 rather than an emulator, and I am now seeing two issues I had not yet seen.

1) How do you work with the softkeys? Can I treat them as keys being pressed, with an event que? I ask because pressing back can lock up the device for a moment, after which I am asked if the program should be shutdown for not responding or not - and if no is pressed, the demo becomes a background behind all the icons.

2) What ever orientation the device starts in is fine, but after rotating the device the aspect becomes very warped. Rotating the device into the orientation it was when the program started makes everything right again.

What code or condition checks am I missing? I am running the allegro example. Any ideas?

Thomas Fjellstrom

All keys should come through as keyboard events. Some work should probably be done to make sure the keyboard event handling doesn't lock up the java thread.

That backgrounding issue has been brought up before. Not sure what is causing that, other than the device supporting multiple GL contexts, and the user thread continuing to run in the background drawing under the main ui.. At least thats my guess.

I'll have to do some testing on my Nexus 7.

alehbeer

I just updated from ~~4.0~~ 4.1 to 4.1.1

The background bug persists, and can now be repeated via:
click back a bunch real fast. select wait. click home.

The rotation bug seems fixed.

Let me know if you can replicate either - if so I will add it to the bug tracker.

Thomas Fjellstrom

Ah, you were using 4.0? That isn't even possible. There was no Android port in 4.0 afaik.

But please try the latest 4.1 release, and Git if possible. Git especially, that's probably the most important.

AMCerasoli

Isn't he talking about Android? Android 4.1, Jelly Bean?

alehbeer

I meant android 4.1 to 4.1.1

Thomas Fjellstrom

OH. Heh. My bad. What version of Allegro are you trying?

alehbeer

Allegro 5.1.3

Thomas Fjellstrom

Would it be possible to try the version from the git repo? That may have some fixes for what you're seeing. (I can't remember for sure)

Trent Gamblin

You MUST handle ALLEGRO_EVENT_DISPLAY_HALT/RESUME_DRAWING and should handle ALLEGRO_EVENT_DISPLAY_SWITCH_OUT/IN also. Take a look at the Allegro demo for Android to see what you need to do: http://www.nooskewl.com/content/open-source/.

EDIT:

I'll try to break it down as best I can remember (in the way I prefer to do it).

1) When you get a HALT_DRAWING, you should set up a condition variable and start a thread with al_run_detached_thread. The code in this thread is pretty simple:

#SelectExpand
  1// Some "global" data, or in some way accessible to both threads
  2ALLEGRO_COND *cond;
  3ALLEGRO_MUTEX *mutex;
  4// This is the event queue your display is registered to
  5ALLEGRO_EVENT_QUEUE *queue;
  6
  7// Here's the thread function
  8void *thread_proc(void *data)
  9{
 10   (void)data;
 11
 12   while (true) {
 13      ALLEGRO_EVENT e;
 14      al_wait_for_event(queue, &e);
 15      if (e.type == ALLEGRO_EVENT_RESUME_DRAWING) {
 16         al_broadcast_cond(cond);
 17         break;
 18      }
 19   }
 20
 21   return NULL;
 22}
 23
 24// Got HALT_DRAWING here
 25cond = al_create_cond();
 26mutex = al_create_mutex();
 27al_run_detached_thread(...);
 28al_acknowledge_drawing_halt(...);
 29al_wait_cond(cond, mutex);
 30al_acknowledge_drawing_resume(...);
 31al_destroy_cond(cond);
 32al_destroy_mutex(mutex);
 33// ... Back to your regularly scheduled programming

Thomas Fjellstrom

I'm wondering why that is required. Can't the main thread just not run things when it knows it can't draw?

Trent Gamblin

Yes, but then you mess up your main loop. Like I said, way I prefer to do it.

EDIT:

And it's impossible to wait on a condition in the main thread, because you have to wait on events, so you'll be spinning cycles needlessly.

Thomas Fjellstrom

Ah. I personally wouldn't find it would mess up the main loop. I'd probably just stop my timer and call it a day. That way no updates at all should happen till the resume drawing event, where you'd start the timer back up.

Trent Gamblin

You can't. Read my edit. Well you can but it's better my way.

Thomas Fjellstrom

I wouldn't wait on a condition. Just wait for the resume event to come back, and set things back up. Basically with the timer[s] stopped, no more events should be able to come back, other than the resume drawing event. so you wait on that, rather than a condition.

Trent Gamblin

Whatever. Won't argue with you. You're "The Android Guy" after all. .

Thomas Fjellstrom

Trent Gamblin said:

Whatever. Won't argue with you. You're "The Android Guy" after all. .

I have to say you've done at least as much work, so you're like a partner in crime.

I could be missing something. Some quirk of android or allegro's interaction with it that needs something that fancy.

alehbeer

I am a little confused how you would add that code into this. I tried, but now I can't get graphics and it doesn't open immediately like it used to - which I believe is possibly caused by my new and not quite clear understanding of ALLEGRO_EVENTS. Here is the example main.c from the allegro5 git.

#SelectExpand
   1#include <allegro5/allegro.h>
   2#include <allegro5/allegro_image.h>
   3#include <allegro5/allegro_primitives.h>
   4#include <allegro5/allegro_android.h> /* al_android_set_apk_file_interface */
   5
   6ALLEGRO_DEBUG_CHANNEL("main")
   7
   8#define MAX_TOUCH 10
   9
  10struct touch {
 bool down;
 double x, y;
  13} touch[MAX_TOUCH];
  14
  15/* debugging */
  16#define print_standard_path(std)                           \
 do {                                                    \ 
    ALLEGRO_PATH *path = al_get_standard_path(std);      \ 
    ALLEGRO_DEBUG(#std ": %s", al_path_cstr(path, '/')); \ 
 } while (0) 
  21
  22static void print_standard_paths(void)
  23{
 print_standard_path(ALLEGRO_RESOURCES_PATH);
 print_standard_path(ALLEGRO_TEMP_PATH);
 print_standard_path(ALLEGRO_USER_DATA_PATH);
 print_standard_path(ALLEGRO_USER_HOME_PATH);
 print_standard_path(ALLEGRO_USER_SETTINGS_PATH);
 print_standard_path(ALLEGRO_USER_DOCUMENTS_PATH);
 print_standard_path(ALLEGRO_EXENAME_PATH);
  31}
  32
  33static void set_transform(ALLEGRO_DISPLAY *dpy)
  34{
 ALLEGRO_TRANSFORM t;
 int w = al_get_display_width(dpy);
 int h = al_get_display_height(dpy);
  38
 // XXX we shouldn't need this in user code
 // glViewport(0, 0, w, h);
  41
 al_identity_transform(&t);
 al_ortho_transform(&t, 0, w, h, 0, -1, 1);
 al_set_projection_transform(dpy, &t);
  45}
  46
  47static void draw_touches(void)
  48{
 int i;
  50
 for (i = 0; i < MAX_TOUCH; i++) {
    if (touch[i].down) {
       al_draw_filled_rectangle(
          touch[i].x-40, touch[i].y-40,
          touch[i].x+40, touch[i].y+40,
          al_map_rgb(100+i*20, 40+i*20, 40+i*20));
    }
 }
  59}
  60
  61int main(int argc, char **argv)
  62{
 ALLEGRO_DISPLAY *dpy;
 ALLEGRO_EVENT_QUEUE *queue;
 ALLEGRO_EVENT event;
 ALLEGRO_TIMER *timer;
 ALLEGRO_BITMAP *image;
  68
 (void) argc;
 (void) argv;
  71
 ALLEGRO_DEBUG("init allegro!");
 if (!al_init()) {
    return 1;
 }
  76
 ALLEGRO_DEBUG("init primitives");
 al_init_primitives_addon();
  79
 ALLEGRO_DEBUG("init image addon");
 al_init_image_addon();
  82
 ALLEGRO_DEBUG("init touch input");
 al_install_touch_input();
  85
 ALLEGRO_DEBUG("init keyboard");
 al_install_keyboard();
  88
 ALLEGRO_DEBUG("creating display");
 dpy = al_create_display(800, 480);
 if (!dpy) {
    ALLEGRO_ERROR("failed to create display!");
    return 1;
 }
  95
 print_standard_paths();
  97
 /* This is loaded from assets in the apk. */
 al_android_set_apk_file_interface();
 image = al_load_bitmap("alexlogo.png");
 if (!image) {
    ALLEGRO_DEBUG("failed to load alexlogo.png");
    return 1;
 }
 al_set_standard_file_interface();
 106
 al_convert_mask_to_alpha(image, al_map_rgb(255,0,255));
 108
 queue = al_create_event_queue();
 al_register_event_source(queue, al_get_display_event_source(dpy));
 al_register_event_source(queue, al_get_touch_input_event_source());
 al_register_event_source(queue, al_get_keyboard_event_source());
 113
 timer = al_create_timer(1/60.0);
 al_register_event_source(queue, al_get_timer_event_source(timer));
 al_start_timer(timer);
 117
 bool draw = true;
 bool running = true;
 bool paused = false;
 int count = 0;
 122
 while (running) {
    al_wait_for_event(queue, &event);
 125
    switch (event.type) {
       case ALLEGRO_EVENT_TOUCH_BEGIN:
          //ALLEGRO_DEBUG("touch %i begin", event.touch.id);
          touch[event.touch.id].down = true;
          touch[event.touch.id].x = event.touch.x;
          touch[event.touch.id].y = event.touch.y;
          break;
 133
       case ALLEGRO_EVENT_TOUCH_END:
          //ALLEGRO_DEBUG("touch %i end", event.touch.id);
          touch[event.touch.id].down = false;
          touch[event.touch.id].x = 0.0;
          touch[event.touch.id].y = 0.0;
          break;
 140
       case ALLEGRO_EVENT_TOUCH_MOVE:
          //ALLEGRO_DEBUG("touch %i move: %fx%f", event.touch.id, event.touch.x, event.touch.y);
          touch[event.touch.id].x = event.touch.x;
          touch[event.touch.id].y = event.touch.y;
          break;
 146
       case ALLEGRO_EVENT_TOUCH_CANCEL:
          //ALLEGRO_DEBUG("touch %i canceled", event.touch.id);
          break;
 150
       case ALLEGRO_EVENT_KEY_UP:
          if (event.keyboard.keycode == ALLEGRO_KEY_BACK) {
             ALLEGRO_DEBUG("back key pressed, exit!");
             running = false;
          }
          else {
             ALLEGRO_DEBUG("%i key pressed", event.keyboard.keycode);
          }
          break;
 160
       case ALLEGRO_EVENT_TIMER:
          draw = true;
          if (count == 60) {
             ALLEGRO_DEBUG("tick");
             count = 0;
          }
          count++;
          break;
 169
       case ALLEGRO_EVENT_DISPLAY_CLOSE:
          ALLEGRO_DEBUG("display close");
          running = false;
          break;
 174
       case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
          ALLEGRO_DEBUG("halt drawing");
          // Stop the timer so we don't run at all while our display isn't
          // active.
          al_stop_timer(timer);
          //al_set_target_backbuffer(0);
          ALLEGRO_DEBUG("after set target");
          paused = true;
          draw = false;
          al_acknowledge_drawing_halt(dpy);
          break;
 186
       case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
          ALLEGRO_DEBUG("resume drawing");
 189
          al_acknowledge_drawing_resume(dpy, NULL);
          ALLEGRO_DEBUG("done waiting for surface recreated");
 192
          al_start_timer(timer);
          //al_set_target_backbuffer(dpy);
          //_al_android_setup_opengl_view(dpy);
          paused = false;
          break;
 198
       case ALLEGRO_EVENT_DISPLAY_RESIZE:
          ALLEGRO_DEBUG("display resize");
          al_acknowledge_resize(dpy);
          ALLEGRO_DEBUG("done resize");
          set_transform(dpy);
          break;
 205
       case ALLEGRO_EVENT_DISPLAY_ORIENTATION:
          set_transform(dpy);
          break;
    }
 210
    if (draw && al_event_queue_is_empty(queue)) {
       draw = false;
       al_clear_to_color(al_map_rgb(255, 255, 255));
       if (image) {
          al_draw_bitmap(image,
             al_get_display_width(dpy)/2 - al_get_bitmap_width(image)/2,
             al_get_display_height(dpy)/2 - al_get_bitmap_height(image)/2,
             0);
       }
       draw_touches();
       al_flip_display();
    }
 }
 224
 ALLEGRO_DEBUG("done");
 return 0;
 227}
 228
 229/* vim: set sts=3 sw=3 et: */

Thread #610921. Printed from Allegro.cc