Refactored OpenGL embedder that works on Android, Mac or Linux.

runtime/embedders/openglui/android/eventloop.cc

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#include "embedders/openglui/android/eventloop.h"
+
+#include "embedders/openglui/common/log.h"
+
+EventLoop::EventLoop(android_app* application)
+    : enabled_(false),
+      quit_(false),
+      application_(application),
+      lifecycle_handler_(NULL),
+      input_handler_(NULL) {
+  application_->onAppCmd = ActivityCallback;
+  application_->onInputEvent = InputCallback;
+  application_->userData = this;
+}
+
+void EventLoop::Run(LifeCycleHandler* lifecycle_handler,
+                    InputHandler* input_handler) {
+  int32_t result;
+  int32_t events;
+  android_poll_source* source;
+
+  lifecycle_handler_ = lifecycle_handler;
+  input_handler_ = input_handler;
+  LOGI("Starting event loop");
+  while (true) {
+    // If not enabled, block on events. If enabled, don't block
+    // so we can do useful work in onStep.
+    while ((result = ALooper_pollAll(enabled_ ? 0 : -1,
+                                     NULL,
+                                     &events,
+                                     reinterpret_cast<void**>(&source))) >= 0) {
+      if (source != NULL) {
+        source->process(application_, source);
+      }
+      if (application_->destroyRequested) {
+        return;
+      }
+    }
+    if (enabled_ && !quit_) {
+      LOGI("step");
+      if (lifecycle_handler_->OnStep() != 0) {
+        quit_ = true;
+        ANativeActivity_finish(application_->activity);
+      }
+    }
+  }
+}
+
+// Called when we gain focus.
+void EventLoop::Activate() {
+  LOGI("activate");
+  if (!enabled_ && application_->window != NULL) {
+    quit_ = false;
+    enabled_ = true;
+    if (lifecycle_handler_->OnActivate() != 0) {
+      quit_ = true;
+      ANativeActivity_finish(application_->activity);
+    }
+  }
+}
+
+// Called when we lose focus.
+void EventLoop::Deactivate() {
+  LOGI("deactivate");
+  if (enabled_) {
+    lifecycle_handler_->OnDeactivate();
+    enabled_ = false;
+  }
+}
+
+void EventLoop::ProcessActivityEvent(int32_t command) {
+  switch (command) {
+    case APP_CMD_CONFIG_CHANGED:
+      lifecycle_handler_->OnConfigurationChanged();
+      break;
+    case APP_CMD_INIT_WINDOW:
+      lifecycle_handler_->OnCreateWindow();
+      break;
+    case APP_CMD_DESTROY:
+      lifecycle_handler_->OnDestroy();
+      break;
+    case APP_CMD_GAINED_FOCUS:
+      Activate();
+      lifecycle_handler_->OnGainedFocus();
+      break;
+    case APP_CMD_LOST_FOCUS:
+      lifecycle_handler_->OnLostFocus();
+      Deactivate();
+      break;
+    case APP_CMD_LOW_MEMORY:
+      lifecycle_handler_->OnLowMemory();
+      break;
+    case APP_CMD_PAUSE:
+      lifecycle_handler_->OnPause();
+      Deactivate();
+      break;
+    case APP_CMD_RESUME:
+      lifecycle_handler_->OnResume();
+      break;
+    case APP_CMD_SAVE_STATE:
+      lifecycle_handler_->OnSaveState(&application_->savedState,
+                                    &application_->savedStateSize);
+      break;
+    case APP_CMD_START:
+      lifecycle_handler_->OnStart();
+      break;
+    case APP_CMD_STOP:
+      lifecycle_handler_->OnStop();
+      break;
+    case APP_CMD_TERM_WINDOW:
+      lifecycle_handler_->OnDestroyWindow();
+      Deactivate();
+      break;
+    default:
+      break;
+  }
+}
+
+bool EventLoop::OnTouchEvent(AInputEvent* event) {
+  int32_t type = AMotionEvent_getAction(event);
+  MotionEvent motion_event;
+  switch (type) {
+    case AMOTION_EVENT_ACTION_DOWN:
+      motion_event = kMotionDown;
+      break;
+    case AMOTION_EVENT_ACTION_UP:
+      motion_event = kMotionUp;
+      break;
+    case AMOTION_EVENT_ACTION_MOVE:
+      motion_event = kMotionMove;
+      break;
+    case AMOTION_EVENT_ACTION_CANCEL:
+      motion_event = kMotionCancel;
+      break;
+    case AMOTION_EVENT_ACTION_OUTSIDE:
+      motion_event = kMotionOutside;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_DOWN:
+      motion_event = kMotionPointerDown;
+      break;
+    case AMOTION_EVENT_ACTION_POINTER_UP:
+      motion_event = kMotionPointerUp;
+      break;
+    default:
+      return false;
+  }
+  // For now we just get the last coords.
+  float move_x = AMotionEvent_getX(event, 0);
+  float move_y = AMotionEvent_getY(event, 0);
+  int64_t when = AMotionEvent_getEventTime(event);
+  LOGI("Got motion event %d at %f, %f", type, move_x, move_y);
+
+  if (input_handler_->OnMotionEvent(motion_event, when, move_x, move_y) != 0) {
+    return false;
+  }
+  return true;
+}
+
+bool EventLoop::OnKeyEvent(AInputEvent* event) {
+  int32_t type = AKeyEvent_getAction(event);
+  KeyEvent key_event;
+  switch (type) {
+    case AKEY_EVENT_ACTION_DOWN:
+      key_event = kKeyDown;
+      break;
+    case AKEY_EVENT_ACTION_UP:
+      key_event = kKeyUp;
+      break;
+    case AKEY_EVENT_ACTION_MULTIPLE:
+      key_event = kKeyMultiple;
+      break;
+    default:
+      return false;
+  }
+  int32_t flags = AKeyEvent_getFlags(event);
+  /* Get the key code of the key event.
+   * This is the physical key that was pressed, not the Unicode character. */
+  int32_t key_code = AKeyEvent_getKeyCode(event);
+  /* Get the meta key state. */
+  int32_t meta_state = AKeyEvent_getMetaState(event);
+  /* Get the repeat count of the event.
+   * For both key up an key down events, this is the number of times the key
+   * has repeated with the first down starting at 0 and counting up from
+   * there.  For multiple key events, this is the number of down/up pairs
+   * that have occurred. */
+  int32_t repeat = AKeyEvent_getRepeatCount(event);
+
+  /* Get the time of the most recent key down event, in the     
+   * java.lang.System.nanoTime() time base.  If this is a down event,   
+   * this will be the same as eventTime.        
+   * Note that when chording keys, this value is the down time of the most      
+   * recently pressed key, which may not be the same physical key of this       
+   * event. */  
+  // TODO(gram): Use or remove this.
+  // int64_t key_down_time = AKeyEvent_getDownTime(event);
+
+  /* Get the time this event occurred, in the
+   * java.lang.System.nanoTime() time base. */
+  int64_t when = AKeyEvent_getEventTime(event);
+
+  LOGI("Got key event %d %d", type, key_code);
+  if (input_handler_->OnKeyEvent(key_event, when, flags, key_code,
+                             meta_state, repeat) != 0) {
+    return false;
+  }
+  return true;
+}
+
+int32_t EventLoop::ProcessInputEvent(AInputEvent* event) {
+  int32_t event_type = AInputEvent_getType(event);
+  LOGI("Got input event type %d", event_type);
+  switch (event_type) {
+    case AINPUT_EVENT_TYPE_MOTION:
+      if (AInputEvent_getSource(event) == AINPUT_SOURCE_TOUCHSCREEN) {
+          return OnTouchEvent(event);
+      }
+      break;
+    case AINPUT_EVENT_TYPE_KEY:
+      return OnKeyEvent(event);
+  }
+  return 0;
+}
+
+void EventLoop::ActivityCallback(android_app* application, int32_t command) {
+  EventLoop* event_loop = reinterpret_cast<EventLoop*>(application->userData);
+  event_loop->ProcessActivityEvent(command);
+}
+
+int32_t EventLoop::InputCallback(android_app* application,
+                                 AInputEvent* event) {
+  EventLoop* event_loop = reinterpret_cast<EventLoop*>(application->userData);
+  return event_loop->ProcessInputEvent(event);
+}
+