wasm_loading_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_WASM_WASM_LOADING_MANAGER_H_
#define YAZE_APP_PLATFORM_WASM_WASM_LOADING_MANAGER_H_
 
#ifdef __EMSCRIPTEN__
 
#include <atomic>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
 
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmLoadingManager {
 public:
  using LoadingHandle = uint64_t;
 
  static constexpr LoadingHandle kInvalidHandle = 0;
 
  static uint32_t GetJsId(LoadingHandle handle) {
    return static_cast<uint32_t>(handle & 0xFFFFFFFF);
  }
 
  static LoadingHandle BeginLoading(const std::string& task_name);
 
  static void UpdateProgress(LoadingHandle handle, float progress);
 
  static void UpdateMessage(LoadingHandle handle, const std::string& message);
 
  static bool IsCancelled(LoadingHandle handle);
 
  static void EndLoading(LoadingHandle handle);
 
  static bool ReportArenaProgress(int current, int total,
                                  const std::string& item_name);
 
  static void SetArenaHandle(LoadingHandle handle);
 
  static void ClearArenaHandle();
 
 private:
  struct LoadingOperation {
    std::string task_name;
    float progress = 0.0f;
    std::string message;
    std::atomic<bool> cancelled{false};
    bool active = true;
    uint32_t generation = 0;  // Generation counter for validation
  };
 
  static WasmLoadingManager& GetInstance();
 
  WasmLoadingManager();
 
  ~WasmLoadingManager();
 
  // Disable copy and move
  WasmLoadingManager(const WasmLoadingManager&) = delete;
  WasmLoadingManager& operator=(const WasmLoadingManager&) = delete;
  WasmLoadingManager(WasmLoadingManager&&) = delete;
  WasmLoadingManager& operator=(WasmLoadingManager&&) = delete;
 
  static LoadingHandle MakeHandle(uint32_t js_id, uint32_t generation) {
    return (static_cast<uint64_t>(generation) << 32) | js_id;
  }
 
  static uint32_t GetGeneration(LoadingHandle handle) {
    return static_cast<uint32_t>(handle >> 32);
  }
 
  std::atomic<uint32_t> next_js_id_{1};
 
  std::atomic<uint32_t> generation_counter_{1};
 
  std::unordered_map<LoadingHandle, std::unique_ptr<LoadingOperation>>
      operations_;
 
  std::mutex mutex_;
 
  LoadingHandle arena_handle_ = kInvalidHandle;
};
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_APP_PLATFORM_WASM_WASM_LOADING_MANAGER_H_