application.cc

Go to the documentation of this file.

#include "app/application.h"
 
#include <atomic>
#include <chrono>
#include <cstdlib>
#include <ctime>
#include <filesystem>
#include <memory>
#include <string>
#include <utility>
#include "absl/cleanup/cleanup.h"
#include "absl/status/status.h"
#include "activity_file.h"
#include "controller.h"
#include "emu/emulator.h"
#include "emu/i_emulator.h"
 
#ifndef _WIN32
#include <unistd.h>  // getpid()
#endif
 
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/events/core_events.h"
#include "util/log.h"
 
#ifdef YAZE_WITH_GRPC
#include "app/emu/internal_emulator_adapter.h"
#include "app/emu/mesen/mesen_emulator_adapter.h"
#include "app/service/canvas_automation_service.h"
#include "app/service/imgui_test_harness_service.h"
#include "app/service/unified_grpc_server.h"
#include "app/testing/test_manager.h"
#endif
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#include "app/platform/wasm/wasm_bootstrap.h"
#include "app/platform/wasm/wasm_collaboration.h"
#endif
 
namespace yaze {
 
Application& Application::Instance() {
  static Application instance;
  return instance;
}
 
void Application::Initialize(const AppConfig& config) {
  config_ = config;
  LOG_INFO("App", "Initializing Application instance...");
 
  controller_ = std::make_unique<Controller>();
  if (controller_->editor_manager()) {
    controller_->editor_manager()->SetStartupLoadHints(config_);
  }
 
  // Process pending ROM load if we have one (from flags/config - non-WASM only)
  std::string start_path = config_.rom_file;
 
#ifndef __EMSCRIPTEN__
  if (!pending_rom_.empty()) {
    // Pending ROM takes precedence over config (e.g. drag-drop before init)
    start_path = pending_rom_;
    pending_rom_.clear();
    LOG_INFO("App", "Found pending ROM load: %s", start_path.c_str());
  } else if (!start_path.empty()) {
    LOG_INFO("App", "Using configured startup ROM: %s", start_path.c_str());
  } else {
    LOG_INFO("App", "No pending ROM, starting empty.");
  }
#else
  LOG_INFO("App", "WASM build - ROM loading handled via wasm_bootstrap queue.");
  // In WASM, start_path from config might be ignored if we rely on web uploads
  // But we can still try to pass it if it's a server-hosted ROM
#endif
 
  // Always call OnEntry to initialize Window/Renderer, even with empty path
  auto status = controller_->OnEntry(start_path);
  if (!status.ok()) {
    LOG_ERROR("App", "Failed to initialize controller: %s",
              std::string(status.message()).c_str());
    // Window/renderer/ImGui init failed. Do not fall through into the frame
    // loop with uninitialized state: the controller stays inactive, so the
    // main loop exits immediately and Shutdown() tears down anything created.
    return;
  } else {
    LOG_INFO("App", "Controller initialized successfully. Active: %s",
             controller_->IsActive() ? "Yes" : "No");
 
#ifdef YAZE_WITH_GRPC
    test::TestManager::Get().SetFailureScreenshotRequester(
        [controller = controller_.get()](
            const std::string& preferred_path,
            test::TestManager::FailureScreenshotCallback callback) {
          controller->RequestScreenshot({.preferred_path = preferred_path,
                                         .reveal_to_user = false,
                                         .callback = std::move(callback)});
        });
#endif
 
    if (controller_->editor_manager()) {
      // Settings > Test mode stands in for the startup flags, because a GUI
      // agent that launches the app by double-click cannot pass any.
      // Explicit flags still win.
      if (controller_->editor_manager()->user_settings().prefs().test_mode) {
        LOG_INFO("App", "Test mode: hiding welcome and editor picker");
        if (config_.welcome_mode == StartupVisibility::kAuto) {
          config_.welcome_mode = StartupVisibility::kHide;
        }
        if (config_.dashboard_mode == StartupVisibility::kAuto) {
          config_.dashboard_mode = StartupVisibility::kHide;
        }
        config_.enable_test_harness = true;
        // Test mode is for local agents only; do not expose ROM writes to
        // the network.
        config_.test_harness_bind_address = "127.0.0.1";
      }
      controller_->editor_manager()->ApplyStartupVisibility(config_);
    }
 
    // If we successfully loaded a ROM at startup, run startup actions
    if (!start_path.empty() && controller_->editor_manager()) {
      RunStartupActions();
    }
 
#ifdef YAZE_WITH_GRPC
    // Initialize gRPC unified server
    if (config_.enable_test_harness) {
      LOG_INFO("App", "Initializing Unified gRPC Server...");
      canvas_automation_service_ =
          std::make_unique<CanvasAutomationServiceImpl>();
      grpc_server_ = std::make_unique<YazeGRPCServer>();
      grpc_server_->SetBindAddress(config_.test_harness_bind_address);
 
      auto rom_getter = [this]() {
        return controller_->GetCurrentRom();
      };
      auto rom_loader = [this](const std::string& path) -> bool {
        if (!controller_ || !controller_->editor_manager())
          return false;
        auto status = controller_->editor_manager()->OpenRomOrProject(path);
        return status.ok();
      };
 
      emu::IEmulator* emulator_interface = nullptr;
 
      if (config_.backend == "mesen") {
        LOG_INFO("App", "Using Mesen2 backend for emulator service");
        emulator_backend_ =
            std::make_unique<emu::mesen::MesenEmulatorAdapter>();
        emulator_interface = emulator_backend_.get();
      } else {
        emu::Emulator* internal_emulator = nullptr;
        if (controller_->editor_manager()) {
          internal_emulator = &controller_->editor_manager()->emulator();
        } else {
          LOG_WARN("App",
                   "EditorManager not ready; internal emulator services may be "
                   "limited");
        }
 
        auto adapter =
            std::make_unique<emu::InternalEmulatorAdapter>(internal_emulator);
 
        // Set up internal helpers for the adapter
        adapter->SetRomLoader([this](const std::string& path) -> bool {
          if (!controller_ || !controller_->editor_manager())
            return false;
          auto status = controller_->editor_manager()->OpenRomOrProject(path);
          return status.ok();
        });
 
        adapter->SetRomGetter(
            [this]() { return controller_->GetCurrentRom(); });
 
        emulator_backend_ = std::move(adapter);
        emulator_interface = emulator_backend_.get();
      }
 
      // Initialize server with all services
      auto status = grpc_server_->Initialize(
          config_.test_harness_port, emulator_interface, rom_getter, rom_loader,
          &yaze::test::TestManager::Get(),
          nullptr,  // Version manager not ready
          nullptr,  // Approval manager not ready
          canvas_automation_service_.get());
 
      // GetGameState runs on gRPC threads; capture on the render thread.
      // Write a PNG to a unique temp path; GetGameState reads it into the
      // reply and deletes it.
      grpc_server_->SetEmulatorScreenshotCapturer([] {
        static std::atomic<int> next_capture{0};
        const auto path = std::filesystem::temp_directory_path() /
                          absl::StrFormat("yaze_gamestate_%d_%d.png",
                                          static_cast<int>(getpid()),
                                          next_capture.fetch_add(1));
        return test::CaptureScreenshotOnRenderThread(
            path.string(), /*window_title=*/"", test::ScreenshotFormat::kPng);
      });
 
      if (status.ok()) {
        status = grpc_server_->StartAsync();  // Start in background thread
        if (!status.ok()) {
          LOG_ERROR("App", "Failed to start gRPC server: %s",
                    std::string(status.message()).c_str());
        } else {
          LOG_INFO("App", "Unified gRPC server started on port %d",
                   config_.test_harness_port);
        }
      } else {
        LOG_ERROR("App", "Failed to initialize gRPC server: %s",
                  std::string(status.message()).c_str());
      }
 
      // Connect services to controller/editor manager
      if (canvas_automation_service_) {
        controller_->SetCanvasAutomationService(
            canvas_automation_service_.get());
      }
    }
#endif
  }
 
#ifdef __EMSCRIPTEN__
  // Register the ROM load handler now that controller is ready.
  yaze::app::wasm::SetRomLoadHandler(
      [](std::string path) { Application::Instance().LoadRom(path); });
#else
  // Create activity file for instance discovery (non-WASM only).
  // Prefer $XDG_RUNTIME_DIR (0700 per-user) over world-readable /tmp.
  auto pid = getpid();
  const char* runtime_dir = std::getenv("XDG_RUNTIME_DIR");
  const char* status_dir = (runtime_dir && *runtime_dir) ? runtime_dir : "/tmp";
  activity_file_ = std::make_unique<app::ActivityFile>(
      absl::StrFormat("%s/yaze-%d.status", status_dir, pid));
  UpdateActivityStatus();
  LOG_INFO("App", "Activity file created: %s",
           activity_file_->GetPath().c_str());
#endif
}
 
void Application::Tick() {
  if (!controller_)
    return;
  // A blocking native dialog (the iOS document picker) runs a nested run loop
  // from inside a frame, and the display link then calls Tick() again.
  // Starting an ImGui frame inside another one aborts in NewFrame().
  if (in_tick_)
    return;
  in_tick_ = true;
  absl::Cleanup end_tick = [this] {
    in_tick_ = false;
  };
 
  // Calculate delta time
  auto now = std::chrono::steady_clock::now();
  if (first_frame_) {
    delta_time_ = 0.016f;  // Assume ~60fps for first frame
    first_frame_ = false;
  } else {
    auto elapsed = std::chrono::duration<float>(now - last_frame_time_);
    delta_time_ = elapsed.count();
  }
  last_frame_time_ = now;
 
  // Publish FrameBeginEvent for pre-frame (non-ImGui) work
  if (auto* bus = editor::ContentRegistry::Context::event_bus()) {
    bus->Publish(editor::FrameBeginEvent::Create(delta_time_));
  }
 
#ifdef __EMSCRIPTEN__
  auto& wasm_collab = app::platform::GetWasmCollaborationInstance();
  wasm_collab.ProcessPendingChanges();
#endif
 
  controller_->OnInput();
  auto status = controller_->OnLoad();
  if (!status.ok()) {
    LOG_ERROR("App", "Controller Load Error: %s",
              std::string(status.message()).c_str());
#ifdef __EMSCRIPTEN__
    emscripten_cancel_main_loop();
#endif
    return;
  }
 
  if (!controller_->IsActive()) {
    // Window closed
    // LOG_INFO("App", "Controller became inactive");
  }
 
  controller_->DoRender();
 
  // Publish FrameEndEvent for cleanup operations
  if (auto* bus = editor::ContentRegistry::Context::event_bus()) {
    bus->Publish(editor::FrameEndEvent::Create(delta_time_));
  }
}
 
void Application::LoadRom(const std::string& path) {
  LOG_INFO("App", "Requesting ROM load: %s", path.c_str());
 
  if (!controller_) {
#ifdef __EMSCRIPTEN__
    yaze::app::wasm::TriggerRomLoad(path);
    LOG_INFO("App",
             "Forwarded to wasm_bootstrap queue (controller not ready): %s",
             path.c_str());
#else
    pending_rom_ = path;
    LOG_INFO("App", "Queued ROM load (controller not ready): %s", path.c_str());
#endif
    return;
  }
 
  // Controller exists.
  absl::Status status;
  if (!controller_->IsActive()) {
    status = controller_->OnEntry(path);
  } else {
    status = controller_->editor_manager()->OpenRomOrProject(path);
  }
 
  if (!status.ok()) {
    std::string error_msg =
        absl::StrCat("Failed to load ROM: ", status.message());
    LOG_ERROR("App", "%s", error_msg.c_str());
 
#ifdef __EMSCRIPTEN__
    EM_ASM(
        {
          var msg = UTF8ToString($0);
          console.error(msg);
          alert(msg);
        },
        error_msg.c_str());
#endif
  } else {
    LOG_INFO("App", "ROM loaded successfully: %s", path.c_str());
 
    // Run startup actions whenever a new ROM is loaded IF it matches our startup config
    // (Optional: we might only want to run actions once at startup, but for CLI usage usually
    // you load one ROM and want the actions applied to it).
    // For now, we'll only run actions if this is the first load or if explicitly requested.
    // Actually, simpler: just run them. The user can close cards if they want.
    RunStartupActions();
 
#ifndef __EMSCRIPTEN__
    // Update activity file with new ROM path
    UpdateActivityStatus();
#endif
 
#ifdef __EMSCRIPTEN__
    EM_ASM(
        { console.log("ROM loaded successfully: " + UTF8ToString($0)); },
        path.c_str());
#endif
  }
}
 
void Application::RunStartupActions() {
  if (!controller_ || !controller_->editor_manager())
    return;
 
  auto* manager = controller_->editor_manager();
  manager->ProcessStartupActions(config_);
}
 
#ifndef __EMSCRIPTEN__
void Application::UpdateActivityStatus() {
  if (!activity_file_)
    return;
 
  app::ActivityStatus status;
  status.pid = getpid();
  status.version = YAZE_VERSION_STRING;
  status.start_timestamp = std::time(nullptr);
 
  if (controller_ && controller_->editor_manager()) {
    auto* rom = controller_->GetCurrentRom();
    status.active_rom = rom ? rom->filename() : "";
  }
 
#ifdef YAZE_WITH_GRPC
  if (config_.enable_test_harness && config_.test_harness_port > 0) {
    status.socket_path =
        absl::StrFormat("localhost:%d", config_.test_harness_port);
  }
#endif
 
  activity_file_->Update(status);
}
#endif
 
#ifdef __EMSCRIPTEN__
extern "C" void SyncFilesystem();
#endif
 
void Application::Shutdown() {
#ifdef __EMSCRIPTEN__
  // Sync IDBFS to persist any changes before shutdown
  LOG_INFO("App", "Syncing filesystem before shutdown...");
  SyncFilesystem();
#endif
 
#ifdef YAZE_WITH_GRPC
  if (grpc_server_) {
    LOG_INFO("App", "Shutting down Unified gRPC Server...");
    grpc_server_->Shutdown();
    grpc_server_.reset();
  }
  canvas_automation_service_.reset();
  test::TestManager::Get().SetFailureScreenshotRequester({});
#endif
 
#ifndef __EMSCRIPTEN__
  // Clean up activity file for instance discovery
  if (activity_file_) {
    LOG_INFO("App", "Removing activity file: %s",
             activity_file_->GetPath().c_str());
    activity_file_.reset();  // Destructor deletes the file
  }
#endif
 
  if (controller_) {
    controller_->OnExit();
    controller_.reset();
  }
}
 
}  // namespace yaze