Centralize legacy app startup

src/app.cpp

@@ -6,10 +6,12 @@
 #include "node_progress_bar.h"
 #include "mp4enc.h"
 #include "app_core/app_status.h"
+#include "app_core/app_startup.h"
 #include "app_core/canvas_tool_ui.h"
 #include "app_core/document_recording.h"
 #include "app_core/document_route.h"
 #include "app_core/document_session.h"
+#include "legacy_app_startup_services.h"
 #include "legacy_document_open_services.h"
 #include "legacy_document_session_services.h"
 #include "legacy_recording_services.h"
@@ -436,12 +438,20 @@ void App::init()
             LOG("OpenGL startup state failed: %s", startup_state_status.message);
     });
 
-    int run_counter = Settings::value<Serializer::Integer>("run_counter") + 1;
-    Settings::set("run_counter", Serializer::Integer(run_counter));
-    LOG("run_counter %d", run_counter);
-
-    if (!Settings::save())
-        LOG("save preferences failed");
+    const auto startup_plan = pp::app::plan_app_startup(
+        Settings::value<Serializer::Integer>("run_counter"),
+        Settings::value_or<Serializer::Boolean>("auto-timelapse", true),
+        Settings::value_or<Serializer::Boolean>("vr-controllers-enabled", vr_controllers_enabled),
+        check_license());
+    if (!startup_plan) {
+        LOG("App startup plan failed: %s", startup_plan.status().message);
+    } else {
+        const auto persistence_status = pp::panopainter::execute_legacy_app_startup_persistence_plan(
+            *this,
+            startup_plan.value());
+        if (!persistence_status.ok())
+            LOG("App startup persistence failed: %s", persistence_status.message);
+    }
 
     initShaders();
     initAssets();
@@ -450,13 +460,12 @@ void App::init()
 
     uirtt.create(width, height, -1, rgba8_internal_format(), true);
 
-    if (Settings::value_or<Serializer::Boolean>("auto-timelapse", true))
-        rec_start();
-    Settings::value<Serializer::Boolean>("vr-controllers-enabled", vr_controllers_enabled);
-
-    if (!check_license())
-    {
-        message_box("License", "Could not validate this license, running in demo mode.");
+    if (startup_plan) {
+        const auto startup_status = pp::panopainter::execute_legacy_app_startup_runtime_plan(
+            *this,
+            startup_plan.value());
+        if (!startup_status.ok())
+            LOG("App startup runtime execution failed: %s", startup_status.message);
     }
 }
 

src/app_core/app_startup.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "foundation/result.h"
+
+#include <limits>
+
+namespace pp::app {
+
+struct AppStartupPlan {
+    int previous_run_counter = 0;
+    int next_run_counter = 1;
+    bool save_preferences = true;
+    bool start_timelapse = false;
+    bool vr_controllers_enabled = true;
+    bool show_license_warning = false;
+};
+
+class AppStartupServices {
+public:
+    virtual ~AppStartupServices() = default;
+
+    virtual void store_run_counter(int value) = 0;
+    virtual void save_preferences() = 0;
+    virtual void start_timelapse_recording() = 0;
+    virtual void apply_vr_controllers_enabled(bool enabled) = 0;
+    virtual void show_license_warning() = 0;
+};
+
+[[nodiscard]] inline pp::foundation::Result<AppStartupPlan> plan_app_startup(
+    int current_run_counter,
+    bool auto_timelapse_enabled,
+    bool stored_vr_controllers_enabled,
+    bool license_valid)
+{
+    if (current_run_counter < 0) {
+        return pp::foundation::Result<AppStartupPlan>::failure(
+            pp::foundation::Status::invalid_argument("run counter must not be negative"));
+    }
+
+    if (current_run_counter == std::numeric_limits<int>::max()) {
+        return pp::foundation::Result<AppStartupPlan>::failure(
+            pp::foundation::Status::out_of_range("run counter would overflow"));
+    }
+
+    AppStartupPlan plan;
+    plan.previous_run_counter = current_run_counter;
+    plan.next_run_counter = current_run_counter + 1;
+    plan.start_timelapse = auto_timelapse_enabled;
+    plan.vr_controllers_enabled = stored_vr_controllers_enabled;
+    plan.show_license_warning = !license_valid;
+    return pp::foundation::Result<AppStartupPlan>::success(plan);
+}
+
+[[nodiscard]] inline pp::foundation::Status execute_app_startup_plan(
+    const AppStartupPlan& plan,
+    AppStartupServices& services)
+{
+    if (plan.previous_run_counter < 0 || plan.next_run_counter <= plan.previous_run_counter) {
+        return pp::foundation::Status::invalid_argument("startup plan has invalid run counter state");
+    }
+
+    services.store_run_counter(plan.next_run_counter);
+    if (plan.save_preferences) {
+        services.save_preferences();
+    }
+    if (plan.start_timelapse) {
+        services.start_timelapse_recording();
+    }
+    services.apply_vr_controllers_enabled(plan.vr_controllers_enabled);
+    if (plan.show_license_warning) {
+        services.show_license_warning();
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] inline pp::foundation::Status execute_app_startup_persistence_plan(
+    const AppStartupPlan& plan,
+    AppStartupServices& services)
+{
+    if (plan.previous_run_counter < 0 || plan.next_run_counter <= plan.previous_run_counter) {
+        return pp::foundation::Status::invalid_argument("startup plan has invalid run counter state");
+    }
+
+    services.store_run_counter(plan.next_run_counter);
+    if (plan.save_preferences) {
+        services.save_preferences();
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] inline pp::foundation::Status execute_app_startup_runtime_plan(
+    const AppStartupPlan& plan,
+    AppStartupServices& services)
+{
+    if (plan.previous_run_counter < 0 || plan.next_run_counter <= plan.previous_run_counter) {
+        return pp::foundation::Status::invalid_argument("startup plan has invalid run counter state");
+    }
+
+    if (plan.start_timelapse) {
+        services.start_timelapse_recording();
+    }
+    services.apply_vr_controllers_enabled(plan.vr_controllers_enabled);
+    if (plan.show_license_warning) {
+        services.show_license_warning();
+    }
+
+    return pp::foundation::Status::success();
+}
+
+} // namespace pp::app

src/legacy_app_startup_services.cpp

@@ -0,0 +1,76 @@
+#include "pch.h"
+
+#include "legacy_app_startup_services.h"
+
+#include "app.h"
+#include "serializer.h"
+#include "settings.h"
+
+namespace pp::panopainter {
+namespace {
+
+class LegacyAppStartupServices final : public pp::app::AppStartupServices {
+public:
+    explicit LegacyAppStartupServices(App& app) noexcept
+        : app_(app)
+    {
+    }
+
+    void store_run_counter(int value) override
+    {
+        Settings::set("run_counter", Serializer::Integer(value));
+        LOG("run_counter %d", value);
+    }
+
+    void save_preferences() override
+    {
+        if (!Settings::save())
+            LOG("save preferences failed");
+    }
+
+    void start_timelapse_recording() override
+    {
+        app_.rec_start();
+    }
+
+    void apply_vr_controllers_enabled(bool enabled) override
+    {
+        app_.vr_controllers_enabled = enabled;
+    }
+
+    void show_license_warning() override
+    {
+        app_.message_box("License", "Could not validate this license, running in demo mode.");
+    }
+
+private:
+    App& app_;
+};
+
+} // namespace
+
+pp::foundation::Status execute_legacy_app_startup_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan)
+{
+    LegacyAppStartupServices services(app);
+    return pp::app::execute_app_startup_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_app_startup_persistence_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan)
+{
+    LegacyAppStartupServices services(app);
+    return pp::app::execute_app_startup_persistence_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_app_startup_runtime_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan)
+{
+    LegacyAppStartupServices services(app);
+    return pp::app::execute_app_startup_runtime_plan(plan, services);
+}
+
+} // namespace pp::panopainter

src/legacy_app_startup_services.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "app_core/app_startup.h"
+
+class App;
+
+namespace pp::panopainter {
+
+[[nodiscard]] pp::foundation::Status execute_legacy_app_startup_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan);
+[[nodiscard]] pp::foundation::Status execute_legacy_app_startup_persistence_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan);
+[[nodiscard]] pp::foundation::Status execute_legacy_app_startup_runtime_plan(
+    App& app,
+    const pp::app::AppStartupPlan& plan);
+
+} // namespace pp::panopainter