wasm_storage_quota.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_WASM_STORAGE_QUOTA_H_
#define YAZE_APP_PLATFORM_WASM_STORAGE_QUOTA_H_
 
#ifdef __EMSCRIPTEN__
 
#include <emscripten.h>
#include <emscripten/val.h>
#include <atomic>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmStorageQuota {
 public:
  struct StorageInfo {
    size_t used_bytes = 0;      
    size_t quota_bytes = 0;     
    float usage_percent = 0.0f; 
    bool persistent = false;    
  };
 
  struct StorageItem {
    std::string key;
    size_t compressed_size = 0;
    size_t original_size = 0;
    double last_access_time = 0.0; 
    float compression_ratio = 0.0f;
  };
 
  void GetStorageInfo(std::function<void(const StorageInfo&)> callback);
 
  void CompressAndStore(const std::string& key,
                        const std::vector<uint8_t>& data,
                        std::function<void(bool success)> callback);
 
  void LoadAndDecompress(const std::string& key,
                         std::function<void(std::vector<uint8_t>)> callback);
 
  void EvictOldest(int count, std::function<void(int evicted)> callback);
 
  void EvictToTarget(float target_percent,
                     std::function<void(int evicted)> callback);
 
  void UpdateAccessTime(const std::string& key);
 
  void GetStoredItems(
      std::function<void(std::vector<StorageItem>)> callback);
 
  void DeleteItem(const std::string& key,
                  std::function<void(bool success)> callback);
 
  void ClearAll(std::function<void()> callback);
 
  static bool IsSupported();
 
  static WasmStorageQuota& Get();
 
  // Configuration constants
  static constexpr float kDefaultTargetUsage = 70.0f; 
  static constexpr float kWarningThreshold = 80.0f;   
  static constexpr float kCriticalThreshold = 90.0f;  
  static constexpr size_t kMinQuotaBytes = 50 * 1024 * 1024; 
 
 private:
  WasmStorageQuota() = default;
 
  // Compression helpers (using browser's CompressionStream API)
  void CompressData(const std::vector<uint8_t>& input,
                    std::function<void(std::vector<uint8_t>)> callback);
  void DecompressData(const std::vector<uint8_t>& input,
                      std::function<void(std::vector<uint8_t>)> callback);
 
  // Internal storage operations
  void StoreCompressedData(const std::string& key,
                           const std::vector<uint8_t>& compressed_data,
                           size_t original_size,
                           std::function<void(bool)> callback);
  void LoadCompressedData(const std::string& key,
                         std::function<void(std::vector<uint8_t>, size_t)> callback);
 
  // Metadata management
  void UpdateMetadata(const std::string& key, size_t compressed_size,
                     size_t original_size);
  void LoadMetadata(std::function<void()> callback);
  void SaveMetadata(std::function<void()> callback);
 
  // Storage monitoring
  void CheckQuotaAndEvict(size_t new_size_bytes,
                          std::function<void(bool)> callback);
 
  // Thread safety
  mutable std::mutex mutex_;
 
  // Cached metadata (key -> last access time in ms)
  std::map<std::string, double> access_times_;
  std::map<std::string, StorageItem> item_metadata_;
  std::atomic<bool> metadata_loaded_{false};
 
  // Current storage state
  StorageInfo last_storage_info_;
  std::atomic<double> last_quota_check_time_{0.0};
};
 
// clang-format off
 
// JavaScript bridge functions for storage quota API
EM_JS(void, wasm_storage_quota_estimate, (int callback_id), {
  if (!navigator.storage || !navigator.storage.estimate) {
    // Call back with error values
    Module.ccall('wasm_storage_quota_estimate_callback',
                 null, ['number', 'number', 'number', 'number'],
                 [callback_id, 0, 0, 0]);
    return;
  }
 
  navigator.storage.estimate().then(function(estimate) {
    var used = estimate.usage || 0;
    var quota = estimate.quota || 0;
    var persistent = estimate.persistent ? 1 : 0;
    Module.ccall('wasm_storage_quota_estimate_callback',
                 null, ['number', 'number', 'number', 'number'],
                 [callback_id, used, quota, persistent]);
  }).catch(function(error) {
    console.error('[StorageQuota] Error estimating storage:', error);
    Module.ccall('wasm_storage_quota_estimate_callback',
                 null, ['number', 'number', 'number', 'number'],
                 [callback_id, 0, 0, 0]);
  });
});
 
// Compression using browser's CompressionStream API
EM_JS(void, wasm_compress_data, (const uint8_t* data, size_t size, int callback_id), {
  var input = new Uint8Array(Module.HEAPU8.buffer, data, size);
 
  // Use CompressionStream if available (Chrome 80+, Firefox 113+)
  if (typeof CompressionStream !== 'undefined') {
    var stream = new CompressionStream('deflate');
    var writer = stream.writable.getWriter();
 
    writer.write(input).then(function() {
      return writer.close();
    }).then(function() {
      return new Response(stream.readable).arrayBuffer();
    }).then(function(compressed) {
      var compressedArray = new Uint8Array(compressed);
      var ptr = Module._malloc(compressedArray.length);
      Module.HEAPU8.set(compressedArray, ptr);
      Module.ccall('wasm_compress_callback',
                   null, ['number', 'number', 'number'],
                   [callback_id, ptr, compressedArray.length]);
    }).catch(function(error) {
      console.error('[StorageQuota] Compression error:', error);
      Module.ccall('wasm_compress_callback',
                   null, ['number', 'number', 'number'],
                   [callback_id, 0, 0]);
    });
  } else {
    // Fallback: No compression, return original data
    console.warn('[StorageQuota] CompressionStream not available, storing uncompressed');
    var ptr = Module._malloc(size);
    Module.HEAPU8.set(input, ptr);
    Module.ccall('wasm_compress_callback',
                 null, ['number', 'number', 'number'],
                 [callback_id, ptr, size]);
  }
});
 
EM_JS(void, wasm_decompress_data, (const uint8_t* data, size_t size, int callback_id), {
  var input = new Uint8Array(Module.HEAPU8.buffer, data, size);
 
  if (typeof DecompressionStream !== 'undefined') {
    var stream = new DecompressionStream('deflate');
    var writer = stream.writable.getWriter();
 
    writer.write(input).then(function() {
      return writer.close();
    }).then(function() {
      return new Response(stream.readable).arrayBuffer();
    }).then(function(decompressed) {
      var decompressedArray = new Uint8Array(decompressed);
      var ptr = Module._malloc(decompressedArray.length);
      Module.HEAPU8.set(decompressedArray, ptr);
      Module.ccall('wasm_decompress_callback',
                   null, ['number', 'number', 'number'],
                   [callback_id, ptr, decompressedArray.length]);
    }).catch(function(error) {
      console.error('[StorageQuota] Decompression error:', error);
      Module.ccall('wasm_decompress_callback',
                   null, ['number', 'number', 'number'],
                   [callback_id, 0, 0]);
    });
  } else {
    // Fallback: Assume data is uncompressed
    var ptr = Module._malloc(size);
    Module.HEAPU8.set(input, ptr);
    Module.ccall('wasm_decompress_callback',
                 null, ['number', 'number', 'number'],
                 [callback_id, ptr, size]);
  }
});
 
// Get current timestamp in milliseconds
EM_JS(double, wasm_get_timestamp_ms, (), {
  return Date.now();
});
 
// Check if compression APIs are available
EM_JS(int, wasm_compression_available, (), {
  return (typeof CompressionStream !== 'undefined' &&
          typeof DecompressionStream !== 'undefined') ? 1 : 0;
});
 
// clang-format on
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#else  // !__EMSCRIPTEN__
 
// Stub implementation for non-WASM builds
#include <functional>
#include <string>
#include <vector>
 
namespace yaze {
namespace app {
namespace platform {
 
class WasmStorageQuota {
 public:
  struct StorageInfo {
    size_t used_bytes = 0;
    size_t quota_bytes = 100 * 1024 * 1024;  // 100MB default
    float usage_percent = 0.0f;
    bool persistent = false;
  };
 
  struct StorageItem {
    std::string key;
    size_t compressed_size = 0;
    size_t original_size = 0;
    double last_access_time = 0.0;
    float compression_ratio = 1.0f;
  };
 
  void GetStorageInfo(std::function<void(const StorageInfo&)> callback) {
    StorageInfo info;
    callback(info);
  }
 
  void CompressAndStore(const std::string& key,
                        const std::vector<uint8_t>& data,
                        std::function<void(bool success)> callback) {
    callback(false);
  }
 
  void LoadAndDecompress(const std::string& key,
                         std::function<void(std::vector<uint8_t>)> callback) {
    callback(std::vector<uint8_t>());
  }
 
  void EvictOldest(int count, std::function<void(int evicted)> callback) {
    callback(0);
  }
 
  void EvictToTarget(float target_percent,
                     std::function<void(int evicted)> callback) {
    callback(0);
  }
 
  void UpdateAccessTime(const std::string& key) {}
 
  void GetStoredItems(
      std::function<void(std::vector<StorageItem>)> callback) {
    callback(std::vector<StorageItem>());
  }
 
  void DeleteItem(const std::string& key,
                  std::function<void(bool success)> callback) {
    callback(false);
  }
 
  void ClearAll(std::function<void()> callback) { callback(); }
 
  static bool IsSupported() { return false; }
 
  static WasmStorageQuota& Get() {
    static WasmStorageQuota instance;
    return instance;
  }
 
  static constexpr float kDefaultTargetUsage = 70.0f;
  static constexpr float kWarningThreshold = 80.0f;
  static constexpr float kCriticalThreshold = 90.0f;
  static constexpr size_t kMinQuotaBytes = 50 * 1024 * 1024;
};
 
}  // namespace platform
}  // namespace app
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_APP_PLATFORM_WASM_STORAGE_QUOTA_H_