iidrak-analytics-react 1.2.9 → 1.5.0

package/README.md

@@ -18,8 +18,13 @@ This package relies on several peer dependencies for device info, storage, and s
 ```bash
 npm install iidrak-analytics-react
 
-# Install required peer dependencies
-npm install @react-native-async-storage/async-storage @react-native-community/netinfo react-native-device-info react-native-view-shot react-native-safe-area-context
+# Install required peer dependencies. For storage, choose ONE: MMKV or AsyncStorage
+npm install react-native-nitro-modules react-native-mmkv
+# OR
+npm install @react-native-async-storage/async-storage
+
+# Install core peer dependencies
+npm install @react-native-community/netinfo react-native-device-info react-native-view-shot react-native-safe-area-context
 ```
 
 **iOS Users**: after installing, remember to run:
@@ -44,6 +49,13 @@ The configuration object requires strict structure for `app`, `config`, and `use
 ```javascript
 import { MetaStreamIO, MetaStreamProvider } from 'iidrak-analytics-react';
 
+// Recommended: Import your preferred storage engine
+import { createMMKV } from 'react-native-mmkv';
+const mmkvStorage = createMMKV();
+
+// Alternatively, import AsyncStorage
+// import AsyncStorage from '@react-native-async-storage/async-storage';
+
 const iidrakConfig = {
   // Application Details
   app: {
@@ -70,6 +82,17 @@ const iidrakConfig = {
     sessionLength: 1800,         // Session timeout in seconds (e.g. 30 mins)
     quality: 0.1,                // Recording quality (0.1 - 1.0)
     fps: 2,                      // Frames Per Second for recording
+
+    // Provide the storage engine to the SDK.
+    // Why wrap MMKV? The SDK strictly expects an asynchronous `getItem/setItem` Interface.
+    // MMKV v4 is completely synchronous C++. This wrapper bridges MMKV into a standard Promise architecture.
+    storageEngine: {
+      getItem: async (key) => mmkvStorage.getString(key) || null,
+      setItem: async (key, value) => { mmkvStorage.set(key, value); return Promise.resolve(); },
+      removeItem: async (key) => { mmkvStorage.remove(key); return Promise.resolve(); }
+    },
+    // For AsyncStorage, no wrapper is needed because it natively uses Promises:
+    // storageEngine: AsyncStorage,
   },
 
   // Initial User Info

package/metastreamio/metastreamio.environment.js

@@ -56,82 +56,87 @@ class MetaStreamIOEnvironment {
   }
 
   async logAppInfo() {
-    let app_id = null;
-    let first_installation_time = null;
-    let installation_id = null;
-    let install_referrer = null;
-    let last_update_time = null;
-    let version = null;
-
-    app_id = DeviceInfo.getBundleId() ? DeviceInfo.getBundleId() : null;
-
-    first_installation_time = await DeviceInfo.getFirstInstallTime()
-      .then((result) => {
-        if (this.date.validateDatetime(result)) {
-          return result;
-        } else {
+    if (this._appInfoCached) return this._appInfoCached;
+    if (this._appInfoPromise) return this._appInfoPromise;
+
+    this._appInfoPromise = (async () => {
+      let app_id = null;
+      let first_installation_time = null;
+      let installation_id = null;
+      let install_referrer = null;
+      let last_update_time = null;
+      let version = null;
+
+      app_id = DeviceInfo.getBundleId() ? DeviceInfo.getBundleId() : null;
+
+      first_installation_time = await DeviceInfo.getFirstInstallTime()
+        .then((result) => {
+          if (this.date.validateDatetime(result)) {
+            return result;
+          } else {
+            return null;
+          }
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
           return null;
-        }
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
+        });
 
-    installation_id = "deprecated"; // Constants.installationId;
-
-    install_referrer = await DeviceInfo.getInstallReferrer()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
+      installation_id = "deprecated"; // Constants.installationId;
 
-    last_update_time = await DeviceInfo.getLastUpdateTime()
-      .then((result) => {
-        if (this.date.validateDatetime(result)) {
+      install_referrer = await DeviceInfo.getInstallReferrer()
+        .then((result) => {
           return result;
-        } else {
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
           return null;
-        }
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
-
-    version = DeviceInfo.getVersion() ? DeviceInfo.getVersion() : null;
-
-    this.app_info = new AppInfoModel({
-      first_installation_time: first_installation_time,
-      id: app_id,
-      installation_id: installation_id,
-      install_referrer: install_referrer,
-      last_update_time: last_update_time,
-      version: version,
-    });
+        });
+
+      last_update_time = await DeviceInfo.getLastUpdateTime()
+        .then((result) => {
+          if (this.date.validateDatetime(result)) {
+            return result;
+          } else {
+            return null;
+          }
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+          return null;
+        });
 
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_AppInfo.format(
-        JSON.stringify(this.app_info)
-      )
-    );
+      version = DeviceInfo.getVersion() ? DeviceInfo.getVersion() : null;
 
-    return this.app_info.json();
+      this.app_info = new AppInfoModel({
+        first_installation_time: first_installation_time,
+        id: app_id,
+        installation_id: installation_id,
+        install_referrer: install_referrer,
+        last_update_time: last_update_time,
+        version: version,
+      });
 
-    // return Promise.resolve(this.app_info.json());
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_AppInfo.format(
+          JSON.stringify(this.app_info)
+        )
+      );
+
+      this._appInfoCached = this.app_info.json();
+      return this._appInfoCached;
+    })();
+    return this._appInfoPromise;
   }
 
   async getAppPerformance() {
@@ -185,146 +190,153 @@ class MetaStreamIOEnvironment {
   }
 
   async logDevice() {
-    let brand,
-      device_type,
-      model,
-      operating_system,
-      operating_system_version,
-      pin_or_fingerprint_set,
-      screen_width,
-      screen_height,
-      storage_total,
-      storage_free,
-      supported_architectures,
-      timezone_offset_sec,
-      total_memory,
-      unique_device_id,
-      used_memory;
-
-    brand = await DeviceInfo.getBrand();
-
-    device_type = await DeviceInfo.getDeviceType();
-
-    model = DeviceInfo.getModel();
-
-    operating_system = DeviceInfo.getSystemName();
-
-    operating_system_version = DeviceInfo.getSystemVersion();
-
-    try {
-      screen_height = Math.round(Dimensions.get("window").height);
-    } catch {
-      screen_height = null;
-    }
-
-    try {
-      screen_width = Math.round(Dimensions.get("window").width);
-    } catch {
-      screen_width = null;
-    }
-
-    storage_free = await DeviceInfo.getFreeDiskStorage()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    storage_total = await DeviceInfo.getTotalDiskCapacity()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    supported_architectures = await DeviceInfo.supportedAbis()
-      .then((result) => {
-        return result.join(",");
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    total_memory = await DeviceInfo.getTotalMemory()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    unique_device_id = DeviceInfo.getUniqueId()
-      ? DeviceInfo.getUniqueId()
-      : null;
-
-    used_memory = await DeviceInfo.getUsedMemory()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    try {
-      timezone_offset_sec = this.date.getDeviceTimezoneOffset();
-    } catch {
-      timezone_offset_sec = null;
-    }
-
-    pin_or_fingerprint_set = await DeviceInfo.isPinOrFingerprintSet()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
+    if (this._deviceCached) return this._deviceCached;
+    if (this._devicePromise) return this._devicePromise;
+
+    this._devicePromise = (async () => {
+      let brand,
+        device_type,
+        model,
+        operating_system,
+        operating_system_version,
+        pin_or_fingerprint_set,
+        screen_width,
+        screen_height,
+        storage_total,
+        storage_free,
+        supported_architectures,
+        timezone_offset_sec,
+        total_memory,
+        unique_device_id,
+        used_memory;
+
+      brand = await DeviceInfo.getBrand();
+
+      device_type = await DeviceInfo.getDeviceType();
+
+      model = DeviceInfo.getModel();
+
+      operating_system = DeviceInfo.getSystemName();
+
+      operating_system_version = DeviceInfo.getSystemVersion();
+
+      try {
+        screen_height = Math.round(Dimensions.get("window").height);
+      } catch {
+        screen_height = null;
+      }
+
+      try {
+        screen_width = Math.round(Dimensions.get("window").width);
+      } catch {
+        screen_width = null;
+      }
+
+      storage_free = await DeviceInfo.getFreeDiskStorage()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      storage_total = await DeviceInfo.getTotalDiskCapacity()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      supported_architectures = await DeviceInfo.supportedAbis()
+        .then((result) => {
+          return result.join(",");
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      total_memory = await DeviceInfo.getTotalMemory()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      unique_device_id = DeviceInfo.getUniqueId()
+        ? DeviceInfo.getUniqueId()
+        : null;
+
+      used_memory = await DeviceInfo.getUsedMemory()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      try {
+        timezone_offset_sec = this.date.getDeviceTimezoneOffset();
+      } catch {
+        timezone_offset_sec = null;
+      }
+
+      pin_or_fingerprint_set = await DeviceInfo.isPinOrFingerprintSet()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      this.device = new DeviceModel({
+        brand: brand,
+        device_type: device_type,
+        model: model,
+        operating_system: operating_system,
+        operating_system_version: operating_system_version,
+        pin_or_fingerprint_set: pin_or_fingerprint_set,
+        screen_height: screen_height,
+        screen_width: screen_width,
+        storage_free: storage_free,
+        storage_total: storage_total,
+        supported_architectures: supported_architectures,
+        timezone_offset_sec: timezone_offset_sec,
+        total_memory: total_memory,
+        unique_device_id: unique_device_id,
+        used_memory: used_memory,
       });
 
-    this.device = new DeviceModel({
-      brand: brand,
-      device_type: device_type,
-      model: model,
-      operating_system: operating_system,
-      operating_system_version: operating_system_version,
-      pin_or_fingerprint_set: pin_or_fingerprint_set,
-      screen_height: screen_height,
-      screen_width: screen_width,
-      storage_free: storage_free,
-      storage_total: storage_total,
-      supported_architectures: supported_architectures,
-      timezone_offset_sec: timezone_offset_sec,
-      total_memory: total_memory,
-      unique_device_id: unique_device_id,
-      used_memory: used_memory,
-    });
-
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_Device.format(
-        JSON.stringify(this.device)
-      )
-    );
-
-    return Promise.resolve(this.device.json());
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_Device.format(
+          JSON.stringify(this.device)
+        )
+      );
+
+      this._deviceCached = this.device.json();
+      return this._deviceCached;
+    })();
+    return this._devicePromise;
   }
 
   async getNetworkInfo() {
@@ -338,68 +350,66 @@ class MetaStreamIOEnvironment {
   }
 
   async logNetworkInfo() {
-    let carrier,
-      carrier_iso_country_code,
-      cellular_generation,
-      mobile_country_code,
-      mobile_network_code,
-      network_state_type,
-      net_info;
-
-    carrier = await DeviceInfo.getCarrier()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    net_info = await NetInfo.fetch()
-      .then((state) => {
-        return {
+    if (this._networkCached && (Date.now() - this._networkCachedTime < 5000)) {
+      return this._networkCached;
+    }
+    if (this._networkPromise) return this._networkPromise;
+
+    this._networkPromise = (async () => {
+      let carrier,
+        carrier_iso_country_code,
+        cellular_generation,
+        mobile_country_code,
+        mobile_network_code,
+        network_state_type,
+        net_info;
+
+      carrier = await Promise.race([
+        DeviceInfo.getCarrier().then(r => r).catch(() => null),
+        new Promise(res => setTimeout(() => res(null), 500))
+      ]);
+
+      net_info = await Promise.race([
+        NetInfo.fetch().then((state) => ({
           connection_type: state.type,
           connection_active: state.isConnected,
-          cellular_generation:
-            state.type === "cellular" ? state.details.cellularGeneration : null,
-        };
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
+          cellular_generation: state.type === "cellular" ? state.details.cellularGeneration : null,
+        })).catch(() => ({ connection_type: "unknown", connection_active: true, cellular_generation: null })),
+        new Promise(res => setTimeout(() => res({ connection_type: "unknown", connection_active: true, cellular_generation: null }), 500))
+      ]);
 
-    carrier_iso_country_code = null;
+      carrier_iso_country_code = null;
 
-    cellular_generation = net_info.cellular_generation;
+      cellular_generation = net_info.cellular_generation;
 
-    mobile_country_code = null;
+      mobile_country_code = null;
 
-    mobile_network_code = null;
+      mobile_network_code = null;
 
-    network_state_type = net_info.connection_type;
+      network_state_type = net_info.connection_type;
 
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_Network.format(
-        JSON.stringify(this.network_info)
-      )
-    );
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_Network.format(
+          JSON.stringify(this.network_info)
+        )
+      );
 
-    this.network_info = new NetworkInfoModel({
-      carrier: carrier,
-      carrier_iso_country_code: carrier_iso_country_code,
-      cellular_generation: cellular_generation,
-      mobile_country_code: mobile_country_code,
-      mobile_network_code: mobile_network_code,
-      network_state_type: network_state_type,
-    });
+      this.network_info = new NetworkInfoModel({
+        carrier: carrier,
+        carrier_iso_country_code: carrier_iso_country_code,
+        cellular_generation: cellular_generation,
+        mobile_country_code: mobile_country_code,
+        mobile_network_code: mobile_network_code,
+        network_state_type: network_state_type,
+      });
 
-    return Promise.resolve(this.network_info.json());
+      this._networkCached = this.network_info.json();
+      this._networkCachedTime = Date.now();
+      this._networkPromise = null;
+      return this._networkCached;
+    })();
+    return this._networkPromise;
   }
 }
 

package/metastreamio/metastreamio.interface.js

@@ -82,6 +82,7 @@ class MetaStreamIO {
       silentMode: this.config.silentMode,
       endpoints: this.appConfig.endpoints,
       headers: this.appConfig.headers,
+      storageEngine: this.config.storageEngine,
     });
     this.account = new MetaStreamIOAccountData({
       constants: this.constant,
@@ -469,7 +470,7 @@ class MetaStreamIO {
             );
             return Promise.resolve(event_data);
           } else {
-            this.logger.error(
+            this.logger.warn(
               "event",
               this.constant.MetaStreamIO_Log_EventTrackFailed.format(_data)
             );
@@ -480,13 +481,14 @@ class MetaStreamIO {
             return Promise.reject(_data);
           }
         })
-        .catch((err) => {
-          this.logger.error("event", "<post_event> could not post: " + err);
-          return Promise.reject(err);
+        .catch(async (err) => {
+          this.logger.warn("event", "<post_event> could not post: " + (err.message || JSON.stringify(err)));
+          await this.network.storeOfflineEvent(this.network.endpoint, event_data);
+          return Promise.resolve(event_data); // Resolve to deque, since it's now safely offline
         });
       return status;
     } else {
-      this.logger.error("event", "<post_event> event_data is undefined");
+      this.logger.warn("event", "<post_event> event_data is undefined");
     }
   }
 
@@ -515,7 +517,7 @@ class MetaStreamIO {
             return Promise.resolve();
           })
           .catch((err) => {
-            this.logger.error(
+            this.logger.warn(
               "event",
               "<runQueue> this.post_event failed: " + err
             );
@@ -526,7 +528,7 @@ class MetaStreamIO {
             try {
               this.queue.enqueue(event);
             } catch (err) {
-              this.logger.error(
+              this.logger.warn(
                 "event",
                 "<runQueue> could not enqueue event: " + err
               );

package/metastreamio/metastreamio.network.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import { strf } from "./string.format.js";
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import NetInfo from "@react-native-community/netinfo";
 
 strf();
@@ -15,7 +14,7 @@ const EVENT_QUEUE_KEY = "metastream_offline_events";
  */
 
 class MetaStreamIONetwork {
-  constructor({ constants, endpoints, logger, silentMode, headers } = {}) {
+  constructor({ constants, endpoints, logger, silentMode, headers, storageEngine } = {}) {
     this.silentMode = silentMode;
     this.constant = constants;
     this.endpoint = null;
@@ -23,13 +22,23 @@ class MetaStreamIONetwork {
     this.headers = headers;
     this.logger = logger;
 
+    // Use provided storageEngine from config or fallback to a transient in-memory store
+    this.storageEngine = storageEngine || {
+      _memory: {},
+      getItem: async (key) => this.storageEngine._memory[key] || null,
+      setItem: async (key, value) => { this.storageEngine._memory[key] = value; return Promise.resolve(); },
+      removeItem: async (key) => { delete this.storageEngine._memory[key]; return Promise.resolve(); }
+    };
+
     // Initialize offline handling
     this.initOfflineHandling();
   }
 
   initOfflineHandling() {
+    this.isOnline = true; // Default assume online, Listener updates it
     // Flush on startup if connected
     NetInfo.fetch().then(state => {
+      this.isOnline = state.isConnected;
       if (state.isConnected) {
         this.flushEvents();
       }
@@ -37,10 +46,16 @@ class MetaStreamIONetwork {
 
     // Flush when network comes back online
     NetInfo.addEventListener(state => {
+      this.isOnline = state.isConnected;
       if (state.isConnected) {
         this.flushEvents();
       }
     });
+
+    // Background heartbeat to auto-flush stuck events gracefully
+    this._flushInterval = setInterval(() => {
+      this.flushEvents();
+    }, 3000); // Poll every 3 seconds for perfect sync
   }
 
   reset() {
@@ -53,14 +68,15 @@ class MetaStreamIONetwork {
         this.endpoint = await this.getData({ endpoint: this.endpoints[_e] })
           .then((data) => {
             try {
-              if (data.status === 200) {
+              if (data && data.status > 0) {
                 return this.endpoints[_e];
               }
+              return false;
             } catch (err) {
               return false;
             }
           })
-          .catch(() => { });
+          .catch(() => { return false; });
         if (this.endpoint) {
           this.logger.log(
             "network",
@@ -86,15 +102,12 @@ class MetaStreamIONetwork {
   }
 
   async getData({ endpoint = this.endpoint } = {}) {
-    var rx;
-
     let get_config = {
       method: "GET",
-      // mode: "no-cors", // required for local testing
       cache: "no-cache",
       credentials: "same-origin",
-      redirect: "follow", // manual, *follow, error
-      referrerPolicy: "no-referrer", // no-referrer, *client
+      redirect: "follow",
+      referrerPolicy: "no-referrer",
       headers: {},
     };
 
@@ -103,37 +116,14 @@ class MetaStreamIONetwork {
     }
 
     try {
-      await fetch(endpoint, get_config)
-        .then((response) => {
-          const contentType = response.headers.get("content-type");
-          if (!contentType || !contentType.includes("application/json")) {
-            return null;
-          } else {
-            return response;
-          }
-        })
-        .catch((err) => {
-          return Promise.resolve(err);
-        })
-        .then(async (response) => {
-          rx = {
-            body: await response.json(),
-            status: response.status,
-          };
-        })
-        .catch((err) => {
-          return {
-            body: err,
-            status: 400,
-          };
-        });
-      return rx;
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
+      const response = await Promise.race([
+        fetch(endpoint, get_config),
+        timeoutPromise
+      ]);
+      return { status: response.status, body: "OK" };
     } catch (err) {
-      return Promise.reject(err);
-      throw this.constant.MetaStreamIO_Network_GetDataIssue.format(
-        err,
-        endpoint
-      );
+      return { status: 0, body: String(err) };
     }
   }
 
@@ -155,12 +145,25 @@ class MetaStreamIONetwork {
       };
     }
 
+    if (!this.isOnline) {
+      this.logger.log("network", "Offline detected in postData. Storing event.");
+      const fallbackEndpoint = this.endpoints.length > 0 ? this.endpoints[0] : null;
+      if (fallbackEndpoint) {
+        await this.storeOfflineEvent(fallbackEndpoint + (endpoint ? endpoint : ""), data);
+        return {
+          body: "Stored offline",
+          status: 200
+        };
+      }
+    }
+
     if (!this.endpoint) {
-      _endpoint = await this.testConnection()
-        .then((rx_endpoint) => {
-          return Promise.resolve(rx_endpoint + (endpoint ? endpoint : ""));
-        })
-        .catch((err) => err);
+      const rx_endpoint = await this.testConnection().catch(() => null);
+      if (rx_endpoint) {
+        _endpoint = rx_endpoint + (endpoint ? endpoint : "");
+      } else {
+        _endpoint = null;
+      }
     }
 
     if (_endpoint) {
@@ -198,6 +201,9 @@ class MetaStreamIONetwork {
   }
 
   async post({ data = {}, endpoint = this.endpoint } = {}) {
+    // Non-blocking trigger to flush stuck offline events (if any)
+    this.flushEvents();
+
     let rx = {};
 
     let post_config = {
@@ -217,95 +223,151 @@ class MetaStreamIONetwork {
       post_config.headers = Object.assign(post_config.headers, this.headers);
     }
 
-    let isOffline = false;
-    await NetInfo.fetch().then(state => {
-      if (!state.isConnected) {
-        isOffline = true;
-      }
-    });
-
-    if (isOffline) {
+    if (!this.isOnline) {
       this.logger.log("network", "Offline detected. Storing event.");
       await this.storeOfflineEvent(endpoint, data);
       return { status: 200, body: "Stored offline" };
     }
 
-    await fetch(endpoint, post_config)
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
+
+    await Promise.race([
+      fetch(endpoint, post_config),
+      timeoutPromise
+    ])
       .then((response) => {
+        rx.status = response.status;
         let _contentType = response.headers.get("content-type");
         if (!_contentType || !_contentType.includes("application/json")) {
           return null;
         } else {
-          rx.status = response.status;
           return response;
         }
       })
       .then(async (response) => {
-        rx.body = await response.json();
+        if (response) {
+          rx.body = await response.json();
+        } else {
+          rx.body = "OK";
+        }
       })
       .catch(async (err) => {
-        this.logger.error("network", "fetch() response", err);
-        // Store offline on network error
-        await this.storeOfflineEvent(endpoint, data);
-        rx.status = 200; // Treat as success to deque
-        rx.body = "Stored offline on error";
+        this.logger.warn("network", "fetch() error in post()", err.message || err);
+        rx.status = 500;
+        rx.body = "fetch error";
+        throw err;
       });
 
     return rx;
   }
 
+  async _getQueue() {
+    try {
+      const raw = await this.storageEngine.getItem(EVENT_QUEUE_KEY);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
   async storeOfflineEvent(endpoint, payload) {
     try {
-      const existing = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      const existing = await this._getQueue();
       const newEvent = {
         endpoint,
         payload,
         failedAt: new Date().toISOString(),
       };
       existing.push(newEvent);
-      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(existing));
+      await this.storageEngine.setItem(EVENT_QUEUE_KEY, JSON.stringify(existing));
       this.logger.log("network", `Stored event locally. Queue size: ${existing.length}`);
     } catch (error) {
-      this.logger.error("network", "Failed to store event:", error);
+      this.logger.error("network", "Failed to store event:", error.message || error);
     }
   }
 
   async flushEvents() {
+    if (this._isFlushing) return;
+    this._isFlushing = true;
+
     try {
-      const stored = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      const stored = await this._getQueue();
       if (stored.length === 0) {
         return;
       }
 
       this.logger.log("network", `Flushing ${stored.length} stored event(s)...`);
+
+      // Pre-flight check: Do not spam the Native Bridge with 20 offline events if the server route is down
+      const pingEndpoint = this.endpoint || (this.endpoints.length > 0 ? this.endpoints[0] : null);
+      if (pingEndpoint) {
+        const pingTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 1500));
+        const routeValid = await Promise.race([
+          fetch(pingEndpoint, { method: "OPTIONS" }),
+          pingTimeout
+        ]).then(() => true).catch(() => false);
+
+        if (!routeValid) {
+          this.logger.log("network", "flushEvents aborted: Node route not fully established natively yet.");
+          return;
+        }
+      }
+
       const remainingEvents = [];
 
       for (const e of stored) {
+        let reqHeaders = { "Content-Type": "application/json" };
+        if (this.headers) {
+          reqHeaders = Object.assign(reqHeaders, this.headers);
+        }
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
+
         try {
-          const response = await fetch(e.endpoint, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(e.payload),
-          });
+          const response = await Promise.race([
+            fetch(e.endpoint, {
+              method: "POST",
+              headers: reqHeaders,
+              body: JSON.stringify(e.payload),
+            }),
+            timeoutPromise
+          ]);
 
           if (response.ok) {
-            this.logger.log("network", "Retried & sent event");
+            this.logger.log("network", "Retried & sent event successfully.");
           } else {
-            // Drop event if server rejects it (4xx, 5xx), avoid infinite loop
-            this.logger.warn("network", "Retry failed with non-OK status, dropping event");
+            this.logger.warn("network", `Retry got non-OK status (${response.status}), dropping event.`);
           }
         } catch (err) {
-          // Keep if network error
+          this.logger.log("network", "Retry failed (still offline or bad host), keeping event.", err.message);
           remainingEvents.push(e);
         }
       }
 
-      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(remainingEvents));
+      const currentQueue = await this._getQueue();
+      // Only keep events that were just inserted (after we started flushing)
+      // We assume new events were appended to the end of the array.
+      let newAdditions = [];
+      if (currentQueue.length > stored.length) {
+        newAdditions = currentQueue.slice(stored.length);
+      }
+
+      const updatedQueue = [...remainingEvents, ...newAdditions];
+
+      if (updatedQueue.length > 0) {
+        await this.storageEngine.setItem(EVENT_QUEUE_KEY, JSON.stringify(updatedQueue));
+      } else {
+        await this.storageEngine.removeItem(EVENT_QUEUE_KEY);
+      }
+
       if (remainingEvents.length < stored.length) {
-        this.logger.log("network", `Flush complete. Remaining: ${remainingEvents.length}`);
+        this.logger.log("network", `Flush complete. Remaining: ${updatedQueue.length}`);
       }
     } catch (error) {
-      this.logger.error("network", "Failed to flush events:", error);
+      this.logger.warn("network", "Failed to flush events:", error.message || error);
+    } finally {
+      this._isFlushing = false;
     }
   }
 

package/metastreamio/models/constructor.config.js

@@ -12,6 +12,7 @@ export class ConfigConstructorModel {
     quality = null,
     fps = null,
     recordingEndpoint = null,
+    storageEngine = null,
   } = {}) {
     this.logging = logging;
     this.loggingLevel = loggingLevel;
@@ -26,6 +27,7 @@ export class ConfigConstructorModel {
     this.quality = quality;
     this.fps = fps;
     this.recordingEndpoint = recordingEndpoint;
+    this.storageEngine = storageEngine;
   }
   json() {
     return {
@@ -41,6 +43,7 @@ export class ConfigConstructorModel {
       quality: this.quality,
       fps: this.fps,
       recordingEndpoint: this.recordingEndpoint,
+      storageEngine: this.storageEngine,
     };
   }
 }

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "iidrak-analytics-react",
-  "version": "1.2.9",
+  "version": "1.5.0",
   "description": "react native client for metastreamio",
   "peerDependencies": {
-    "@react-native-async-storage/async-storage": ">=2.2.0",
+    "react-native-mmkv": ">=4.0.0",
+    "react-native-nitro-modules": ">=0.30.0",
+    "@react-native-async-storage/async-storage": ">=1.17.0",
     "@react-native-community/netinfo": ">=11.5.2",
     "react": ">=18.0.0",
     "react-native": ">=0.70.0",
@@ -11,6 +13,17 @@
     "react-native-view-shot": ">=3.0.0",
     "react-native-safe-area-context": ">=4.0.0"
   },
+  "peerDependenciesMeta": {
+    "react-native-mmkv": {
+      "optional": true
+    },
+    "react-native-nitro-modules": {
+      "optional": true
+    },
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "string-format": "^0.5.0"
   },