Android: moved all Android code from the main app into the driver system. All non-driver-FLTK code and main app are now Android-free.

git-svn-id: file:///fltk/svn/fltk/branches/branch-1.4@12719 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

4 files changed, 108 insertions, 52 deletions

diff --git a/src/drivers/Android/Fl_Android_Application.H b/src/drivers/Android/Fl_Android_Application.H
index b141a7e7f..004238371 100644
--- a/src/drivers/Android/Fl_Android_Application.H
+++ b/src/drivers/Android/Fl_Android_Application.H
@@ -119,6 +119,7 @@ public:
   static int8_t read_cmd();
   static void pre_exec_cmd(int8_t cmd);
   static void post_exec_cmd(int8_t cmd);
+  static AInputQueue *input_event_queue() { return pInputQueue; }
 
   static inline ANativeWindow *native_window() { return pNativeWindow; }
   static inline ANativeWindow_Buffer &graphics_buffer() { return pApplicationWindowBuffer; }
diff --git a/src/drivers/Android/Fl_Android_Application.cxx b/src/drivers/Android/Fl_Android_Application.cxx
index 890d175a4..8794ea2b1 100644
--- a/src/drivers/Android/Fl_Android_Application.cxx
+++ b/src/drivers/Android/Fl_Android_Application.cxx
@@ -235,10 +235,18 @@ void Fl_Android_Application::pre_exec_cmd(int8_t cmd)
 
     case APP_CMD_INIT_WINDOW:
       LOGV("APP_CMD_INIT_WINDOW\n");
+      // tell the main thread that we received the window handle
       pthread_mutex_lock(&pMutex);
       pNativeWindow = pPendingWindow;
       pthread_cond_broadcast(&pCond);
       pthread_mutex_unlock(&pMutex);
+      // change the format of the buffers to match our needs
+      // FIXME: current default screen size and format is 600x800xRGB565
+      ANativeWindow_setBuffersGeometry(pNativeWindow,
+                                       600,
+                                       800,
+                                       WINDOW_FORMAT_RGB_565);
+      // tell FLTK that the buffer is available now
       Fl_Android_Window_Driver::expose_all();
       break;
 
@@ -394,13 +402,17 @@ bool Fl_Android_Application::copy_screen()
   bool ret = false;
   if (lock_screen()) {
 
+#if 0
+    // screen activity viewer
     static int i = 0;
     fl_color( (i&1) ? FL_RED : FL_GREEN);
     fl_rectf(i*10, 600+i*10, 50, 50);
     i++;
     if (i>10) i = 0;
+#endif
 
     // TODO: there are endless possibilities to optimize the following code
+    // We are wasting time by copying the entire screen contents at every dirty frame
     // We can identify previously written buffers and copy only those pixels
     // that actually changed.
     const uint16_t *src = (uint16_t*)pApplicationWindowBuffer.bits;
diff --git a/src/drivers/Android/Fl_Android_Screen_Driver.H b/src/drivers/Android/Fl_Android_Screen_Driver.H
index 7948c906f..32ae04899 100644
--- a/src/drivers/Android/Fl_Android_Screen_Driver.H
+++ b/src/drivers/Android/Fl_Android_Screen_Driver.H
@@ -26,6 +26,7 @@
 #define FL_ANDROID_SCREEN_DRIVER_H
 
 #include <FL/Fl_Screen_Driver.H>
+#include <android/input.h>
 //#include <windows.h>
 
 extern void (*fl_unlock_function)();
@@ -39,6 +40,10 @@ class FL_EXPORT Fl_Android_Screen_Driver : public Fl_Screen_Driver
 {
 private:
   int handle_queued_events(double time_to_wait);
+  int handle_app_command();
+  int handle_input_event();
+  int handle_keyboard_event(AInputEvent*);
+  int handle_mouse_event(AInputEvent*);
 
 #if 0
 
diff --git a/src/drivers/Android/Fl_Android_Screen_Driver.cxx b/src/drivers/Android/Fl_Android_Screen_Driver.cxx
index 0a187ca9c..9156d8c83 100644
--- a/src/drivers/Android/Fl_Android_Screen_Driver.cxx
+++ b/src/drivers/Android/Fl_Android_Screen_Driver.cxx
@@ -59,65 +59,103 @@ Fl_Screen_Driver *Fl_Screen_Driver::newScreenDriver()
   return new Fl_Android_Screen_Driver();
 }
 
-int Fl_Android_Screen_Driver::handle_queued_events(double time_to_wait)
+int Fl_Android_Screen_Driver::handle_app_command()
 {
-/*
-  int ALooper_pollAll	(	int 	timeoutMillis,
-                          int * 	outFd,
-                          int * 	outEvents,
-                          void ** 	outData
-  )
-
-  struct engine engine;
-
-  memset(&engine, 0, sizeof(engine));
-  state->userData = &engine;
-  state->onAppCmd = engine_handle_cmd;
-  state->onInputEvent = engine_handle_input;
-  engine.app = state;
-
-  struct timespec now;
-  clock_gettime(CLOCK_MONOTONIC, &now);
-  start_ms = (((int64_t)now.tv_sec)*1000000000LL + now.tv_nsec)/1000000;
-
-  win = new Fl_Window(10, 10, 600, 400, "Hallo");
-  btn = new Fl_Button(190, 200, 280, 35, "Hello, Android!");
-  win->show();
-
-
-  // loop waiting for stuff to do.
-
-  while (1) {
-    // Read all pending events.
-    int ident;
-    int events;
-    struct android_poll_source* source;
-
-    // If not animating, we will block forever waiting for events.
-    // If animating, we loop until all events are read, then continue
-    // to draw the next frame of animation.
-    while ((ident=ALooper_pollAll(engine.animating ? 0 : -1, NULL, &events,
-                                  (void**)&source)) >= 0) {
-
-      // Process this event.
-      if (source != NULL) {
-        source->process(state, source);
-      }
+  int8_t cmd = Fl_Android_Application::read_cmd();
+  Fl_Android_Application::pre_exec_cmd(cmd);
+  // TODO: call Fl::handle() with event parametrs set
+  Fl_Android_Application::post_exec_cmd(cmd);
+  return 1;
+}
 
-      // Check if we are exiting.
-      if (state->destroyRequested != 0) {
-        LOGI("Engine thread destroy requested!");
-        engine_term_display(&engine);
-        return;
+int Fl_Android_Screen_Driver::handle_input_event()
+{
+  AInputQueue *queue = Fl_Android_Application::input_event_queue();
+  AInputEvent *event = NULL;
+
+  if (AInputQueue_getEvent(queue, &event) >= 0) {
+    if (AInputQueue_preDispatchEvent(queue, event)==0) {
+      int consumed = 0;
+      switch (AInputEvent_getType(event)) {
+        case  AINPUT_EVENT_TYPE_KEY:
+          consumed = handle_keyboard_event(event);
+          break;
+        case AINPUT_EVENT_TYPE_MOTION:
+          consumed = handle_mouse_event(event);
+          break;
+        default:
+          // don;t do anything. There may be additional event types in the future
+          break;
       }
+      // TODO: handle all events here
+      AInputQueue_finishEvent(queue, event, consumed);
     }
+  }
+  return 0;
+}
 
-    if (engine.animating) {
-      engine_draw_frame(&engine);
+int Fl_Android_Screen_Driver::handle_keyboard_event(AInputEvent *event)
+{
+  Fl_Android_Application::log_i("Key event: action=%d keyCode=%d metaState=0x%x",
+                                AKeyEvent_getAction(event),
+                                AKeyEvent_getKeyCode(event),
+                                AKeyEvent_getMetaState(event));
+  return 0;
+}
+
+int Fl_Android_Screen_Driver::handle_mouse_event(AInputEvent *event)
+{
+  Fl::e_x = Fl::e_x_root = AMotionEvent_getX(event, 0) * 600 /
+                           ANativeWindow_getWidth(Fl_Android_Application::native_window());
+  Fl::e_y = Fl::e_y_root = AMotionEvent_getY(event, 0) * 800 /
+                           ANativeWindow_getHeight(Fl_Android_Application::native_window());
+  Fl::e_state = FL_BUTTON1;
+  Fl::e_keysym = FL_Button + 1;
+  if (AMotionEvent_getAction(event) == AMOTION_EVENT_ACTION_DOWN) {
+    Fl::e_is_click = 1;
+    Fl::handle(FL_PUSH, Fl::first_window());
+    Fl_Android_Application::log_i("Mouse push %d at %d, %d", Fl::event_button(), Fl::event_x(),
+                                  Fl::event_y());
+  } else if (AMotionEvent_getAction(event) == AMOTION_EVENT_ACTION_MOVE) {
+    Fl::handle(FL_DRAG, Fl::first_window());
+  } else if (AMotionEvent_getAction(event) == AMOTION_EVENT_ACTION_UP) {
+    Fl::e_state = 0;
+    Fl::handle(FL_RELEASE, Fl::first_window());
+  }
+  return 1;
+}
+
+/**
+ * Handle all events in the even queue.
+ *
+ * FIXME: what should this function return?
+ *
+ * @param time_to_wait
+ * @return we do not know
+ */
+int Fl_Android_Screen_Driver::handle_queued_events(double time_to_wait)
+{
+  int ret = 0;
+  // Read all pending events.
+  int ident;
+  int events;
+  struct android_poll_source *source;
+
+  for (;;) {
+    ident = ALooper_pollAll(Fl::damage() ? 0 : -1, NULL, &events, (void **) &source);
+    switch (ident) {
+      // FIXME:  ALOOPER_POLL_WAKE = -1, ALOOPER_POLL_CALLBACK = -2, ALOOPER_POLL_TIMEOUT = -3, ALOOPER_POLL_ERROR = -4
+      case LOOPER_ID_MAIN:
+        ret = handle_app_command();
+        break;
+      case LOOPER_ID_INPUT:
+        ret = handle_input_event();
+        break;
+      case -3: return ret;
+      default: return ret;
     }
   }
-  */
-  return -1;
+  return ret;
 }