Function android_main

native-activity/app/src/main/cpp/main.cpp:279–331

* `android_main()` is the entry point for an app using `native_app_glue`. * * This function is called from a separate thread spawned from * `ANativeActivity_onCreate`, which is the native equivalent of the * `onCreate` stage in the activity lifecycle: * https://developer.android.com/guide/components/activities/activity-lifecycle * * The `android_main()` implementation typically will perform

 * enter the main event loop, and shut down if necessary.
 */
void android_main(android_app* state) {
  Engine engine{state};

  // onAppCmd is called whenever native_app_glue receives one of the activity
  // lifecycle events from the framework:
  // https://developer.android.com/guide/components/activities/activity-lifecycle
  //
  // Typical native Android applications would implement the various
  // onPause(), onResume(), etc in JNI methods. native_app_glue handles that
  // for us and instead presents those method calls as if they were a pollable
  // event queue. Our engine_handle_cmd callback is the function that will
  // respond to new events in that queue.
  state->onAppCmd = engine_handle_cmd;

  // The userData property will be passed to the callback we registered with
  // onAppCmd.
  state->userData = &engine;

  // destroyRequested will be set when onDestroy() is called:
  // https://developer.android.com/guide/components/activities/activity-lifecycle#ondestroy
  while (!state->destroyRequested) {
    // native_app_glue communicates events to the app using Looper rather than
    // method calls like a Java activity would use. Looper is an Android API
    // similar to POSIX's select(2):
    // https://developer.android.com/ndk/reference/group/looper#alooper
    //
    // Whenever an activity lifecycle method is called on our ANativeActivity,
    // or an input event is received, native_app_glue will forward that to our
    // app as a looper event.
    //
    // Polling looper can be done in either a blocking or non-blocking manner.
    // If your app needs to wake periodically on this thread, pass a value for
    // the poll timeout. Most of the things you'd normally do during this loop
    // (respond to input or sensor updates, or even render the next frame of
    // your game) should be driven by callbacks registered with those
    // subsystems though rather than done here. Our main loop doesn't need to
    // do anything other than process looper events.
    android_poll_source* source = nullptr;
    auto result = ALooper_pollOnce(-1, nullptr, nullptr,
                                   reinterpret_cast<void**>(&source));
    if (result == ALOOPER_POLL_ERROR) {
      fatal("ALooper_pollOnce returned an error");
    }

    if (source != nullptr) {
      source->process(state, source);
    }
  }

  // Most cleanup code should actually run in response to activity lifecycle
  // events that are processed in engine_handle_cmd rather than after the main
  // loop exits, as would be more typical of main loops on desktop platforms.
}