Class Engine

native-activity/app/src/main/cpp/main.cpp:72–231

* The implementation for our app. * * This class implements the activity lifecycle behaviors akin to how Activity * would in a Java app. With native_app_glue, those lifecycle events are instead * communicated to this class from engine_handle_cmd, which is in turned called * by looper (see the description below in android_main). * * The comments here will briefly explain some aspects of the

 * and the other docs in that section for more information.
 */
class Engine {
 public:
  explicit Engine(android_app* app) : app_(app) {}

  void AttachWindow() {
    // This is called whenever a new native window is created for our app, so we
    // need to reinitialize the buffer format to the format our render loop
    // expects.
    //
    // Attaching the window will not cause the app to start running its update
    // and render loop. The app's update cycle is separately enabled by
    // Engine::Resume.
    if (ANativeWindow_setBuffersGeometry(
            app_->window, 0, 0, AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM) < 0) {
      LOGE("Unable to set window buffer geometry");
      window_initialized = false;
      return;
    }
    window_initialized = true;
    color_ = Color::kRed;
    last_update_ = std::chrono::steady_clock::now();
  }

  void DetachWindow() {
    // This is called whenever the native window for our app is destroyed. That
    // does not necessarily mean that the app is being killed, as it is also
    // done when the screen rotates.
    //
    // For a more typical app where the rendering is done with OpenGL or Vulkan,
    // this is where you'd perform any window cleanup needed by those
    // frameworks. For our app, it's sufficient to just set a flag to disable
    // our render loop.
    window_initialized = false;
  }

  /// Resumes ticking the application.
  void Resume() {
    // This is called whenever the activity is resumed (brought into the
    // foreground). When that happens, we schedule our next update tick with
    // Choreographer. Choreographer is the Android system that paces app render
    // loops. If you instead render new frames in a loop without frame pacing,
    // you risk rendering more quickly than the display pipeline is able to
    // present new frames. This will increase the latency between frame
    // submission and presentation.
    // https://developer.android.com/ndk/reference/group/choreographer

    // Checked to make sure we don't double schedule Choreographer.
    if (!running_) {
      running_ = true;
      ScheduleNextTick();
    }
  }

  /// Pauses ticking the application.
  ///
  /// When paused, sensor and input events will still be processed, but the
  /// update and render parts of the loop will not run.
  void Pause() {