@onekeyfe/react-native-async-storage 3.0.80 → 3.0.81-alpha.1

package/android/src/main/java/com/asyncstorage/RNCAsyncStorageModule.kt

@@ -292,6 +292,10 @@ class RNCAsyncStorageModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    override fun reloadManifest(promise: Promise) {
+        promise.resolve(null)
+    }
+
     // --- Private helpers (ported from AsyncLocalStorageUtil.java) ---
 
     private fun ensureDatabase(): Boolean {

package/ios/AsyncStorage.h

@@ -24,4 +24,7 @@
 - (void)clear:(RCTPromiseResolveBlock)resolve
        reject:(RCTPromiseRejectBlock)reject;
 
+- (void)reloadManifest:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject;
+
 @end

package/ios/AsyncStorage.mm

@@ -711,4 +711,24 @@ static void RCTStorageDirectoryMigrationCheck(NSString *fromStorageDirectory,
     });
 }
 
+- (void)reloadManifest:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        BOOL previousHaveSetup = self->_haveSetup;
+        NSMutableDictionary<NSString *, NSString *> *previousManifest = self->_manifest;
+        self->_haveSetup = NO;
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            self->_haveSetup = previousHaveSetup;
+            self->_manifest = previousManifest;
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+        resolve(nil);
+    });
+}
+
 @end

package/lib/module/NativeAsyncStorage.web.js

@@ -135,7 +135,8 @@ const AsyncStorage = {
   multiMerge: (keyValuePairs, callback) => {
     const promises = keyValuePairs.map(item => AsyncStorage.mergeItem(item[0], item[1]));
     return createPromiseAll(promises, callback);
-  }
+  },
+  reloadManifest: () => Promise.resolve()
 };
 export default AsyncStorage;
 //# sourceMappingURL=NativeAsyncStorage.web.js.map

package/lib/module/index.js

@@ -1,10 +1,41 @@
 "use strict";
 
 import NativeModule from './NativeAsyncStorage';
+import { forwardAsyncStorageWriteIfNeeded } from "./runtimeConfig.js";
+async function forwardWriteAndReloadManifestIfNeeded(method, args) {
+  if (!(await forwardAsyncStorageWriteIfNeeded(method, args))) {
+    return false;
+  }
+  await NativeModule.reloadManifest();
+  return true;
+}
+async function reloadManifestBestEffort() {
+  try {
+    await NativeModule.reloadManifest();
+  } catch {
+    // Keep using this runtime's current manifest when a refresh is temporarily
+    // unavailable, for example while iOS data-protected files are locked.
+  }
+}
+async function runLocalWriteWithFreshManifest(write) {
+  // This narrows the local-write stale manifest window, but it does not make
+  // uninjected writes cross-runtime serialized. Writes that already completed
+  // before forwarder installation keep the legacy local-write semantics.
+  await reloadManifestBestEffort();
+  await write();
+}
+async function runReadWithFreshManifest(read) {
+  // iOS keeps one manifest cache per runtime/module instance while the files on
+  // disk are shared. Refresh before reads so main can observe bg-origin writes
+  // without routing reads through the bg runtime. Android/web implementations
+  // expose reloadManifest as a no-op.
+  await reloadManifestBestEffort();
+  return read();
+}
 function createAsyncStorage() {
   const getItem = async (key, callback) => {
     try {
-      const result = await NativeModule.multiGet([key]);
+      const result = await runReadWithFreshManifest(() => NativeModule.multiGet([key]));
       const value = result?.[0]?.[1] ?? null;
       callback?.(null, value);
       return value;
@@ -16,7 +47,9 @@ function createAsyncStorage() {
   };
   const setItem = async (key, value, callback) => {
     try {
-      await NativeModule.multiSet([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet([[key, value]]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -26,7 +59,9 @@ function createAsyncStorage() {
   };
   const removeItem = async (key, callback) => {
     try {
-      await NativeModule.multiRemove([key]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove([key]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -36,7 +71,9 @@ function createAsyncStorage() {
   };
   const mergeItem = async (key, value, callback) => {
     try {
-      await NativeModule.multiMerge([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge([[key, value]]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -46,7 +83,9 @@ function createAsyncStorage() {
   };
   const clear = async callback => {
     try {
-      await NativeModule.clear();
+      if (!(await forwardWriteAndReloadManifestIfNeeded('clear', []))) {
+        await NativeModule.clear();
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -56,7 +95,7 @@ function createAsyncStorage() {
   };
   const getAllKeys = async callback => {
     try {
-      const keys = await NativeModule.getAllKeys();
+      const keys = await runReadWithFreshManifest(() => NativeModule.getAllKeys());
       callback?.(null, keys);
       return keys;
     } catch (e) {
@@ -70,7 +109,7 @@ function createAsyncStorage() {
   };
   const multiGet = async (keys, callback) => {
     try {
-      const result = await NativeModule.multiGet([...keys]);
+      const result = await runReadWithFreshManifest(() => NativeModule.multiGet([...keys]));
       callback?.(null, result);
       return result;
     } catch (e) {
@@ -82,7 +121,9 @@ function createAsyncStorage() {
   const multiSet = async (keyValuePairs, callback) => {
     try {
       const mutablePairs = keyValuePairs.map(([k, v]) => [k, v]);
-      await NativeModule.multiSet(mutablePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [mutablePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet(mutablePairs));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -92,7 +133,10 @@ function createAsyncStorage() {
   };
   const multiRemove = async (keys, callback) => {
     try {
-      await NativeModule.multiRemove([...keys]);
+      const mutableKeys = [...keys];
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [mutableKeys]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove(mutableKeys));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -102,7 +146,9 @@ function createAsyncStorage() {
   };
   const multiMerge = async (keyValuePairs, callback) => {
     try {
-      await NativeModule.multiMerge(keyValuePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [keyValuePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge(keyValuePairs));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -126,4 +172,5 @@ function createAsyncStorage() {
 }
 const AsyncStorage = createAsyncStorage();
 export default AsyncStorage;
+export { setAsyncStorageShouldForwardWriteGetter, setAsyncStorageWriteForwarder } from "./runtimeConfig.js";
 //# sourceMappingURL=index.js.map

package/lib/module/runtimeConfig.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const runtimeGlobal = globalThis;
+let shouldForwardWriteGetter = runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+let writeForwarder = runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+export function setAsyncStorageShouldForwardWriteGetter(getter) {
+  shouldForwardWriteGetter = getter;
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter = getter;
+}
+export function setAsyncStorageWriteForwarder(forwarder) {
+  writeForwarder = forwarder;
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder = forwarder;
+}
+function getShouldForwardWriteGetter() {
+  return shouldForwardWriteGetter ?? runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+}
+function getWriteForwarder() {
+  return writeForwarder ?? runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+}
+function shouldForwardWriteToBackground() {
+  return getShouldForwardWriteGetter()?.() ?? false;
+}
+export function shouldForwardAsyncStorageWrite() {
+  return shouldForwardWriteToBackground();
+}
+export async function forwardAsyncStorageWrite(method, args) {
+  const forwarder = getWriteForwarder();
+  if (!forwarder) {
+    throw new Error('AsyncStorage write forwarder is not configured.');
+  }
+  await forwarder(method, args);
+}
+export async function forwardAsyncStorageWriteIfNeeded(method, args) {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+  await forwardAsyncStorageWrite(method, args);
+  return true;
+}
+//# sourceMappingURL=runtimeConfig.js.map

package/lib/typescript/src/NativeAsyncStorage.d.ts

@@ -6,6 +6,7 @@ export interface Spec extends TurboModule {
     multiMerge(keyValuePairs: [string, string][]): Promise<void>;
     getAllKeys(): Promise<string[]>;
     clear(): Promise<void>;
+    reloadManifest(): Promise<void>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/NativeAsyncStorage.web.d.ts

@@ -6,6 +6,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { AsyncStorageStatic } from './types';
-declare const AsyncStorage: AsyncStorageStatic;
+type AsyncStorageWebStatic = AsyncStorageStatic & {
+    reloadManifest: () => Promise<void>;
+};
+declare const AsyncStorage: AsyncStorageWebStatic;
 export default AsyncStorage;
 //# sourceMappingURL=NativeAsyncStorage.web.d.ts.map

package/lib/typescript/src/index.d.ts

@@ -1,5 +1,7 @@
 import type { AsyncStorageStatic } from './types';
 declare const AsyncStorage: AsyncStorageStatic;
 export default AsyncStorage;
+export type { AsyncStorageShouldForwardWriteGetter, AsyncStorageWriteArgs, AsyncStorageWriteArgsByMethod, AsyncStorageWriteForwarder, AsyncStorageWriteMethod, } from './runtimeConfig';
 export type { AsyncStorageStatic, Callback, CallbackWithResult, KeyValuePair, MultiCallback, MultiGetCallback, } from './types';
+export { setAsyncStorageShouldForwardWriteGetter, setAsyncStorageWriteForwarder, } from './runtimeConfig';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/runtimeConfig.d.ts

@@ -0,0 +1,16 @@
+export type AsyncStorageWriteArgsByMethod = {
+    clear: [];
+    multiSet: [[string, string][]];
+    multiRemove: [string[]];
+    multiMerge: [[string, string][]];
+};
+export type AsyncStorageWriteMethod = keyof AsyncStorageWriteArgsByMethod;
+export type AsyncStorageWriteArgs<T extends AsyncStorageWriteMethod = AsyncStorageWriteMethod> = AsyncStorageWriteArgsByMethod[T];
+export type AsyncStorageShouldForwardWriteGetter = () => boolean;
+export type AsyncStorageWriteForwarder = <T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>) => Promise<void>;
+export declare function setAsyncStorageShouldForwardWriteGetter(getter: AsyncStorageShouldForwardWriteGetter): void;
+export declare function setAsyncStorageWriteForwarder(forwarder: AsyncStorageWriteForwarder): void;
+export declare function shouldForwardAsyncStorageWrite(): boolean;
+export declare function forwardAsyncStorageWrite<T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>): Promise<void>;
+export declare function forwardAsyncStorageWriteIfNeeded<T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean>;
+//# sourceMappingURL=runtimeConfig.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-async-storage",
-  "version": "3.0.80",
+  "version": "3.0.81-alpha.1",
   "description": "react-native-async-storage",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -164,5 +164,6 @@
       "release-it"
     ],
     "version": "0.56.0"
-  }
+  },
+  "stableVersion": "3.0.80"
 }

package/src/NativeAsyncStorage.ts

@@ -8,6 +8,7 @@ export interface Spec extends TurboModule {
   multiMerge(keyValuePairs: [string, string][]): Promise<void>;
   getAllKeys(): Promise<string[]>;
   clear(): Promise<void>;
+  reloadManifest(): Promise<void>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('RNCAsyncStorage');

package/src/NativeAsyncStorage.web.ts

@@ -17,6 +17,9 @@ import type {
 type OnMultiResult = Function;
 // eslint-disable-next-line @typescript-eslint/ban-types
 type OnResult = Function;
+type AsyncStorageWebStatic = AsyncStorageStatic & {
+  reloadManifest: () => Promise<void>;
+};
 
 const merge = mergeOptions.bind({
   concatArrays: true,
@@ -73,7 +76,7 @@ function createPromiseAll<
   );
 }
 
-const AsyncStorage: AsyncStorageStatic = {
+const AsyncStorage: AsyncStorageWebStatic = {
   /**
    * Fetches `key` value.
    */
@@ -176,6 +179,8 @@ const AsyncStorage: AsyncStorageStatic = {
     );
     return createPromiseAll(promises, callback);
   },
+
+  reloadManifest: () => Promise.resolve(),
 };
 
 export default AsyncStorage;

package/src/index.tsx

@@ -1,10 +1,54 @@
 import NativeModule from './NativeAsyncStorage';
+import { forwardAsyncStorageWriteIfNeeded } from './runtimeConfig';
+import type {
+  AsyncStorageWriteArgs,
+  AsyncStorageWriteMethod,
+} from './runtimeConfig';
 import type { AsyncStorageStatic } from './types';
 
+async function forwardWriteAndReloadManifestIfNeeded<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>) {
+  if (!(await forwardAsyncStorageWriteIfNeeded(method, args))) {
+    return false;
+  }
+
+  await NativeModule.reloadManifest();
+  return true;
+}
+
+async function reloadManifestBestEffort() {
+  try {
+    await NativeModule.reloadManifest();
+  } catch {
+    // Keep using this runtime's current manifest when a refresh is temporarily
+    // unavailable, for example while iOS data-protected files are locked.
+  }
+}
+
+async function runLocalWriteWithFreshManifest(write: () => Promise<void>) {
+  // This narrows the local-write stale manifest window, but it does not make
+  // uninjected writes cross-runtime serialized. Writes that already completed
+  // before forwarder installation keep the legacy local-write semantics.
+  await reloadManifestBestEffort();
+  await write();
+}
+
+async function runReadWithFreshManifest<T>(read: () => Promise<T>): Promise<T> {
+  // iOS keeps one manifest cache per runtime/module instance while the files on
+  // disk are shared. Refresh before reads so main can observe bg-origin writes
+  // without routing reads through the bg runtime. Android/web implementations
+  // expose reloadManifest as a no-op.
+  await reloadManifestBestEffort();
+  return read();
+}
+
 function createAsyncStorage(): AsyncStorageStatic {
   const getItem: AsyncStorageStatic['getItem'] = async (key, callback) => {
     try {
-      const result = await NativeModule.multiGet([key]);
+      const result = await runReadWithFreshManifest(() =>
+        NativeModule.multiGet([key])
+      );
       const value = result?.[0]?.[1] ?? null;
       callback?.(null, value);
       return value;
@@ -21,7 +65,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiSet([[key, value]]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          [[key, value]],
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet([[key, value]])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -35,7 +87,13 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiRemove([key]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove([key])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -50,7 +108,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiMerge([[key, value]]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
+          [[key, value]],
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge([[key, value]])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -61,7 +127,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const clear: AsyncStorageStatic['clear'] = async (callback) => {
     try {
-      await NativeModule.clear();
+      if (!(await forwardWriteAndReloadManifestIfNeeded('clear', []))) {
+        await NativeModule.clear();
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -72,7 +140,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const getAllKeys: AsyncStorageStatic['getAllKeys'] = async (callback) => {
     try {
-      const keys = await NativeModule.getAllKeys();
+      const keys = await runReadWithFreshManifest(() =>
+        NativeModule.getAllKeys()
+      );
       callback?.(null, keys);
       return keys;
     } catch (e) {
@@ -88,7 +158,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const multiGet: AsyncStorageStatic['multiGet'] = async (keys, callback) => {
     try {
-      const result = await NativeModule.multiGet([...keys]);
+      const result = await runReadWithFreshManifest(() =>
+        NativeModule.multiGet([...keys])
+      );
       callback?.(null, result);
       return result;
     } catch (e) {
@@ -106,7 +178,15 @@ function createAsyncStorage(): AsyncStorageStatic {
       const mutablePairs = keyValuePairs.map(
         ([k, v]) => [k, v] as [string, string]
       );
-      await NativeModule.multiSet(mutablePairs);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          mutablePairs,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet(mutablePairs)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -120,7 +200,16 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiRemove([...keys]);
+      const mutableKeys = [...keys];
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [
+          mutableKeys,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove(mutableKeys)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -134,7 +223,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiMerge(keyValuePairs);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
+          keyValuePairs,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge(keyValuePairs)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -162,6 +259,13 @@ const AsyncStorage = createAsyncStorage();
 
 export default AsyncStorage;
 
+export type {
+  AsyncStorageShouldForwardWriteGetter,
+  AsyncStorageWriteArgs,
+  AsyncStorageWriteArgsByMethod,
+  AsyncStorageWriteForwarder,
+  AsyncStorageWriteMethod,
+} from './runtimeConfig';
 export type {
   AsyncStorageStatic,
   Callback,
@@ -170,3 +274,7 @@ export type {
   MultiCallback,
   MultiGetCallback,
 } from './types';
+export {
+  setAsyncStorageShouldForwardWriteGetter,
+  setAsyncStorageWriteForwarder,
+} from './runtimeConfig';

package/src/runtimeConfig.ts

@@ -0,0 +1,86 @@
+export type AsyncStorageWriteArgsByMethod = {
+  clear: [];
+  multiSet: [[string, string][]];
+  multiRemove: [string[]];
+  multiMerge: [[string, string][]];
+};
+
+export type AsyncStorageWriteMethod = keyof AsyncStorageWriteArgsByMethod;
+
+export type AsyncStorageWriteArgs<
+  T extends AsyncStorageWriteMethod = AsyncStorageWriteMethod
+> = AsyncStorageWriteArgsByMethod[T];
+
+export type AsyncStorageShouldForwardWriteGetter = () => boolean;
+
+export type AsyncStorageWriteForwarder = <T extends AsyncStorageWriteMethod>(
+  method: T,
+  args: AsyncStorageWriteArgs<T>
+) => Promise<void>;
+
+type AsyncStorageRuntimeGlobal = typeof globalThis & {
+  __onekeyAsyncStorageShouldForwardWriteGetter?: AsyncStorageShouldForwardWriteGetter;
+  __onekeyAsyncStorageWriteForwarder?: AsyncStorageWriteForwarder;
+};
+
+const runtimeGlobal = globalThis as AsyncStorageRuntimeGlobal;
+
+let shouldForwardWriteGetter: AsyncStorageShouldForwardWriteGetter | undefined =
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+let writeForwarder: AsyncStorageWriteForwarder | undefined =
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+
+export function setAsyncStorageShouldForwardWriteGetter(
+  getter: AsyncStorageShouldForwardWriteGetter
+) {
+  shouldForwardWriteGetter = getter;
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter = getter;
+}
+
+export function setAsyncStorageWriteForwarder(
+  forwarder: AsyncStorageWriteForwarder
+) {
+  writeForwarder = forwarder;
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder = forwarder;
+}
+
+function getShouldForwardWriteGetter() {
+  return (
+    shouldForwardWriteGetter ??
+    runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter
+  );
+}
+
+function getWriteForwarder() {
+  return writeForwarder ?? runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+}
+
+function shouldForwardWriteToBackground() {
+  return getShouldForwardWriteGetter()?.() ?? false;
+}
+
+export function shouldForwardAsyncStorageWrite() {
+  return shouldForwardWriteToBackground();
+}
+
+export async function forwardAsyncStorageWrite<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>): Promise<void> {
+  const forwarder = getWriteForwarder();
+  if (!forwarder) {
+    throw new Error('AsyncStorage write forwarder is not configured.');
+  }
+
+  await forwarder(method, args);
+}
+
+export async function forwardAsyncStorageWriteIfNeeded<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean> {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+
+  await forwardAsyncStorageWrite(method, args);
+  return true;
+}