wasm_autosave.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_WASM_AUTOSAVE_H_
#define YAZE_APP_PLATFORM_WASM_AUTOSAVE_H_
 
#ifdef __EMSCRIPTEN__
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "nlohmann/json.hpp"
 
namespace yaze {
namespace platform {
 
class AutoSaveManager {
 public:
  // Callback types
  using SaveCallback = std::function<nlohmann::json()>;
  using RestoreCallback = std::function<void(const nlohmann::json&)>;
 
  static AutoSaveManager& Instance();
 
  absl::Status Start(int interval_seconds = 60);
 
  absl::Status Stop();
 
  bool IsRunning() const;
 
  void RegisterComponent(const std::string& component_id,
                         SaveCallback save_fn,
                         RestoreCallback restore_fn);
 
  void UnregisterComponent(const std::string& component_id);
 
  absl::Status SaveNow();
 
  void EmergencySave();
 
  bool HasRecoveryData();
 
  absl::StatusOr<nlohmann::json> GetRecoveryInfo();
 
  absl::Status RecoverLastSession();
 
  absl::Status ClearRecoveryData();
 
  void SetInterval(int seconds);
 
  int GetInterval() const { return interval_seconds_; }
 
  void SetEnabled(bool enabled);
 
  bool IsEnabled() const { return enabled_; }
 
  std::chrono::system_clock::time_point GetLastSaveTime() const {
    return last_save_time_;
  }
 
  nlohmann::json GetStatistics() const;
 
 private:
  // Private constructor for singleton
  AutoSaveManager();
  ~AutoSaveManager();
 
  // Delete copy and move constructors
  AutoSaveManager(const AutoSaveManager&) = delete;
  AutoSaveManager& operator=(const AutoSaveManager&) = delete;
  AutoSaveManager(AutoSaveManager&&) = delete;
  AutoSaveManager& operator=(AutoSaveManager&&) = delete;
 
  // Component registration
  struct Component {
    SaveCallback save_fn;
    RestoreCallback restore_fn;
  };
 
  // Internal methods
  void InitializeEventHandlers();
  void CleanupEventHandlers();
  static void TimerCallback(void* user_data);
  absl::Status PerformSave();
  nlohmann::json CollectComponentData();
  absl::Status SaveToStorage(const nlohmann::json& data);
  absl::StatusOr<nlohmann::json> LoadFromStorage();
 
  // Storage keys
  static constexpr const char* kAutoSaveDataKey = "yaze_autosave_data";
  static constexpr const char* kAutoSaveMetaKey = "yaze_autosave_meta";
  static constexpr const char* kRecoveryFlagKey = "yaze_has_recovery";
 
  // Member variables
  mutable std::mutex mutex_;
  std::unordered_map<std::string, Component> components_;
  int interval_seconds_;
  bool enabled_;
  bool running_;
  int timer_id_;
  std::chrono::system_clock::time_point last_save_time_;
 
  // Statistics
  size_t save_count_;
  size_t error_count_;
  size_t recovery_count_;
 
  // Event handler registration state
  bool event_handlers_initialized_;
 
 public:
  // Must be public for emergency save callback access
  static bool emergency_save_triggered_;
};
 
}  // namespace platform
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_APP_PLATFORM_WASM_AUTOSAVE_H_