shell/platform/glfw/client_wrapper/flutter_window_controller.cc

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "include/flutter/flutter_window_controller.h"

#include <algorithm>
#include <iostream>

namespace flutter {

FlutterWindowController::FlutterWindowController(
    const std::string& icu_data_path)
    : icu_data_path_(icu_data_path) {
  init_succeeded_ = FlutterDesktopInit();
}

FlutterWindowController::~FlutterWindowController() {
  if (controller_) {
    FlutterDesktopDestroyWindow(controller_);
  }
  if (init_succeeded_) {
    FlutterDesktopTerminate();
  }
}

bool FlutterWindowController::CreateWindow(
    const WindowProperties& window_properties,
    const std::string& assets_path,
    const std::vector<std::string>& arguments,
    const std::string& aot_library_path) {
  if (!init_succeeded_) {
    std::cerr << "Could not create window; FlutterDesktopInit failed."
              << std::endl;
    return false;
  }

  if (controller_) {
    std::cerr << "Only one Flutter window can exist at a time." << std::endl;
    return false;
  }

  FlutterDesktopWindowProperties c_window_properties = {};
  c_window_properties.title = window_properties.title.c_str();
  c_window_properties.width = window_properties.width;
  c_window_properties.height = window_properties.height;
  c_window_properties.prevent_resize = window_properties.prevent_resize;

  FlutterDesktopEngineProperties c_engine_properties = {};
  c_engine_properties.assets_path = assets_path.c_str();
  c_engine_properties.aot_library_path = aot_library_path.c_str();
  c_engine_properties.icu_data_path = icu_data_path_.c_str();
  std::vector<const char*> engine_switches;
  std::transform(
      arguments.begin(), arguments.end(), std::back_inserter(engine_switches),
      [](const std::string& arg) -> const char* { return arg.c_str(); });
  if (engine_switches.size() > 0) {
    c_engine_properties.switches = &engine_switches[0];
    c_engine_properties.switches_count = engine_switches.size();
  }

  controller_ =
      FlutterDesktopCreateWindow(c_window_properties, c_engine_properties);
  if (!controller_) {
    std::cerr << "Failed to create window." << std::endl;
    return false;
  }
  window_ =
      std::make_unique<FlutterWindow>(FlutterDesktopGetWindow(controller_));
  return true;
}

void FlutterWindowController::DestroyWindow() {
  if (controller_) {
    FlutterDesktopDestroyWindow(controller_);
    controller_ = nullptr;
    window_ = nullptr;
  }
}

FlutterDesktopPluginRegistrarRef FlutterWindowController::GetRegistrarForPlugin(
    const std::string& plugin_name) {
  if (!controller_) {
    std::cerr << "Cannot get plugin registrar without a window; call "
                 "CreateWindow first."
              << std::endl;
    return nullptr;
  }
  return FlutterDesktopGetPluginRegistrar(FlutterDesktopGetEngine(controller_),
                                          plugin_name.c_str());
}

bool FlutterWindowController::RunEventLoopWithTimeout(
    std::chrono::milliseconds timeout) {
  if (!controller_) {
    std::cerr << "Cannot run event loop without a window window; call "
                 "CreateWindow first."
              << std::endl;
    return false;
  }
  uint32_t timeout_milliseconds;
  if (timeout == std::chrono::milliseconds::max()) {
    // The C API uses 0 to represent no timeout, so convert |max| to 0.
    timeout_milliseconds = 0;
  } else if (timeout.count() > UINT32_MAX) {
    timeout_milliseconds = UINT32_MAX;
  } else {
    timeout_milliseconds = static_cast<uint32_t>(timeout.count());
  }
  bool still_running = FlutterDesktopRunWindowEventLoopWithTimeout(
      controller_, timeout_milliseconds);
  if (!still_running) {
    DestroyWindow();
  }
  return still_running;
}

void FlutterWindowController::RunEventLoop() {
  while (RunEventLoopWithTimeout()) {
  }
}

}  // namespace flutter