@onekeyfe/react-native-device-utils 3.0.177 → 3.0.178

package/README.md

@@ -45,6 +45,51 @@ cross-platform guarantee that a service or hardware feature is available.
 
 See [src/ReactNativeDeviceUtils.nitro.ts](src/ReactNativeDeviceUtils.nitro.ts)
 for the complete signatures, enum values and platform notes.
+See [docs/SPEC.md](docs/SPEC.md) for the InMemoryStore contract and acceptance status.
+
+## In-memory store
+
+`ReactNativeDeviceUtils` exposes synchronous Android/iOS methods:
+
+```ts
+type InMemoryValue = string | boolean | number;
+
+getInMemoryValue(key: string): InMemoryValue | undefined;
+setInMemoryValue(key: string, value: InMemoryValue): void;
+removeInMemoryValue(key: string): boolean;
+setInMemoryValueIfAbsent(key: string, value: InMemoryValue): boolean;
+```
+
+Values are strings (including empty strings), booleans, or numbers. Reads preserve
+the original type; false and 0 are stored values rather than missing keys. Numbers
+use IEEE-754 doubles, including negative zero, NaN, and infinities. Objects, arrays,
+null, and undefined are not supported. `setInMemoryValueIfAbsent` inserts
+only when the key is missing and returns whether it inserted. All operations use
+the same native lock. A module recreation, JS reload, or main/background runtime
+recreation retains the same native Map. Process exit discards it. No data is
+persisted, and there is no implicit reset on React lifecycle events.
+
+Keys use exact UTF-8 identity, without Unicode normalization. The store holds at
+most 128 entries; keys are limited to 256 UTF-8 bytes and string values to 4096
+bytes. Boolean and number payloads are fixed size.
+Overlong arguments or a new key at capacity throw synchronously without changing
+the Map. Existing keys can still be replaced or removed; no entry is evicted.
+Both write methods validate their arguments even when the key already exists.
+
+Use namespaced keys. For startup reporting, only main UI may claim
+`analytics:startup:jsReadyTime` or `analytics:startup:uiVisibleTime`. Claim and
+enqueue synchronously; remove the key if local enqueue throws. Keep the key after
+enqueue succeeds; network delivery remains the existing analytics path's job.
+A pending JS logger queue can still lose entries on runtime loss or later queue
+errors; acceptance into that queue does not guarantee delivery.
+
+This API requires a rebuilt native host containing the updated module. It is not
+an OTA-only change. Desktop/web/extension are not implemented by this package.
+
+After `yarn nitrogen`, run `node tests/in-memory-store.cjs` from this package to
+compile the production Swift/Kotlin stores with the generated primitive union,
+exercise type preservation, concurrent claims and independent keys, and run each
+executable in two fresh processes. Requires Swift, Kotlin, and Java.
 
 ## License
 

package/android/src/main/java/com/margelo/nitro/reactnativedeviceutils/InMemoryStore.kt

@@ -0,0 +1,54 @@
+package com.margelo.nitro.reactnativedeviceutils
+
+// Process-owned storage, independent of HybridObjects and React runtimes.
+internal object InMemoryStore {
+    private const val MAX_ENTRIES = 128
+    private const val MAX_KEY_BYTES = 256
+    private const val MAX_VALUE_BYTES = 4096
+    private val values = mutableMapOf<String, InMemoryValue>()
+
+    private fun validateKey(key: String) {
+        require(key.length <= MAX_KEY_BYTES && key.toByteArray(Charsets.UTF_8).size <= MAX_KEY_BYTES) {
+            "InMemoryStore key exceeds 256 UTF-8 bytes"
+        }
+    }
+
+    private fun validateValue(value: InMemoryValue) {
+        val string = value.asSecondOrNull() ?: return
+        require(string.length <= MAX_VALUE_BYTES && string.toByteArray(Charsets.UTF_8).size <= MAX_VALUE_BYTES) {
+            "InMemoryStore value exceeds 4096 UTF-8 bytes"
+        }
+    }
+
+    @Synchronized
+    fun get(key: String): InMemoryValue? {
+        validateKey(key)
+        return values[key]
+    }
+
+    @Synchronized
+    fun set(key: String, value: InMemoryValue) {
+        validateKey(key)
+        validateValue(value)
+        check(values.containsKey(key) || values.size < MAX_ENTRIES) {
+            "InMemoryStore capacity exceeds 128 entries"
+        }
+        values[key] = value
+    }
+
+    @Synchronized
+    fun remove(key: String): Boolean {
+        validateKey(key)
+        return values.remove(key) != null
+    }
+
+    @Synchronized
+    fun setIfAbsent(key: String, value: InMemoryValue): Boolean {
+        validateKey(key)
+        validateValue(value)
+        if (values.containsKey(key)) return false
+        check(values.size < MAX_ENTRIES) { "InMemoryStore capacity exceeds 128 entries" }
+        values[key] = value
+        return true
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativedeviceutils/ReactNativeDeviceUtils.kt

@@ -43,6 +43,15 @@ private data class NavigationBarAppearance(
 @DoNotStrip
 class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEventListener {
 
+  override fun getInMemoryValue(key: String): InMemoryValue? = InMemoryStore.get(key)
+
+  override fun setInMemoryValue(key: String, value: InMemoryValue) = InMemoryStore.set(key, value)
+
+  override fun removeInMemoryValue(key: String): Boolean = InMemoryStore.remove(key)
+
+  override fun setInMemoryValueIfAbsent(key: String, value: InMemoryValue): Boolean =
+    InMemoryStore.setIfAbsent(key, value)
+
   /**
    * Foldable device model constants for various manufacturers.
    * Reference: https://storage.googleapis.com/play_public/supported_devices.html

package/ios/InMemoryStore.swift

@@ -0,0 +1,70 @@
+import Foundation
+
+// The singleton outlives HybridObjects and React runtimes. Only process exit
+// clears it; no value holds a JS object or writes to persistent storage.
+final class InMemoryStore {
+    static let shared = InMemoryStore()
+    private static let maxEntries = 128
+    private static let maxKeyBytes = 256
+    private static let maxValueBytes = 4096
+    private let lock = NSLock()
+    // Swift String equality normalizes Unicode; Data preserves exact key bytes.
+    private var values: [Data: InMemoryValue] = [:]
+
+    private init() {}
+
+    private func keyData(_ key: String) throws -> Data {
+        guard key.utf8.prefix(Self.maxKeyBytes + 1).count <= Self.maxKeyBytes else {
+            throw budgetError("InMemoryStore key exceeds 256 UTF-8 bytes")
+        }
+        return Data(key.utf8)
+    }
+
+    private func validateValue(_ value: InMemoryValue) throws {
+        guard case .second(let string) = value else { return }
+        guard string.utf8.prefix(Self.maxValueBytes + 1).count <= Self.maxValueBytes else {
+            throw budgetError("InMemoryStore value exceeds 4096 UTF-8 bytes")
+        }
+    }
+
+    private func budgetError(_ message: String) -> NSError {
+        return NSError(domain: "InMemoryStore", code: 1,
+                       userInfo: [NSLocalizedDescriptionKey: message])
+    }
+
+    func get(_ key: String) throws -> InMemoryValue? {
+        lock.lock()
+        defer { lock.unlock() }
+        return values[try keyData(key)]
+    }
+
+    func set(_ key: String, _ value: InMemoryValue) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        let data = try keyData(key)
+        try validateValue(value)
+        guard values[data] != nil || values.count < Self.maxEntries else {
+            throw budgetError("InMemoryStore capacity exceeds 128 entries")
+        }
+        values[data] = value
+    }
+
+    func remove(_ key: String) throws -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return values.removeValue(forKey: try keyData(key)) != nil
+    }
+
+    func setIfAbsent(_ key: String, _ value: InMemoryValue) throws -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        let data = try keyData(key)
+        try validateValue(value)
+        guard values[data] == nil else { return false }
+        guard values.count < Self.maxEntries else {
+            throw budgetError("InMemoryStore capacity exceeds 128 entries")
+        }
+        values[data] = value
+        return true
+    }
+}

package/ios/ReactNativeDeviceUtils.swift

@@ -173,6 +173,24 @@ class ReactNativeDeviceUtils: HybridReactNativeDeviceUtilsSpec {
         // Android-only system UI.
     }
 
+    // MARK: - In-memory store
+
+    func getInMemoryValue(key: String) throws -> InMemoryValue? {
+        return try InMemoryStore.shared.get(key)
+    }
+
+    func setInMemoryValue(key: String, value: InMemoryValue) throws {
+        try InMemoryStore.shared.set(key, value)
+    }
+
+    func removeInMemoryValue(key: String) throws -> Bool {
+        return try InMemoryStore.shared.remove(key)
+    }
+
+    func setInMemoryValueIfAbsent(key: String, value: InMemoryValue) throws -> Bool {
+        return try InMemoryStore.shared.setIfAbsent(key, value)
+    }
+
     // MARK: - LaunchOptionsManager
 
     func getLaunchOptions() throws -> Promise<LaunchOptions> {

package/lib/typescript/src/ReactNativeDeviceUtils.nitro.d.ts

@@ -1,4 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules';
+export type InMemoryValue = string | boolean | number;
 export type UserInterfaceStyle = 'light' | 'dark' | 'unspecified';
 export type AndroidChannel = 'direct' | 'google' | 'huawei' | 'unknown';
 export type InstallerPackageName = 'appStore' | 'testFlight' | 'other' | 'playStore' | 'huaweiAppGallery' | 'unknown';
@@ -48,6 +49,10 @@ export interface ReactNativeDeviceUtils extends HybridObject<{
     saveDeviceToken(token: string): Promise<void>;
     registerDeviceToken(): Promise<boolean>;
     getStartupTime(): Promise<number>;
+    getInMemoryValue(key: string): InMemoryValue | undefined;
+    setInMemoryValue(key: string, value: InMemoryValue): void;
+    removeInMemoryValue(key: string): boolean;
+    setInMemoryValueIfAbsent(key: string, value: InMemoryValue): boolean;
     getAndClearColdStartLocalNotification(): Promise<string>;
     exitApp(): void;
     getCurrentWebViewPackageInfo(): Promise<WebViewPackageInfo>;

package/nitrogen/generated/android/c++/JHybridReactNativeDeviceUtilsSpec.cpp

@@ -32,6 +32,8 @@ namespace margelo::nitro::reactnativedeviceutils { enum class UserInterfaceStyle
 #include <string>
 #include <optional>
 #include <NitroModules/JUnit.hpp>
+#include <variant>
+#include "JInMemoryValue.hpp"
 #include "WebViewPackageInfo.hpp"
 #include "JWebViewPackageInfo.hpp"
 #include "GooglePlayServicesStatus.hpp"
@@ -250,6 +252,25 @@ namespace margelo::nitro::reactnativedeviceutils {
       return __promise;
     }();
   }
+  std::optional<std::variant<bool, std::string, double>> JHybridReactNativeDeviceUtilsSpec::getInMemoryValue(const std::string& key) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JInMemoryValue>(jni::alias_ref<jni::JString> /* key */)>("getInMemoryValue");
+    auto __result = method(_javaPart, jni::make_jstring(key));
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridReactNativeDeviceUtilsSpec::setInMemoryValue(const std::string& key, const std::variant<bool, std::string, double>& value) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */, jni::alias_ref<JInMemoryValue> /* value */)>("setInMemoryValue");
+    method(_javaPart, jni::make_jstring(key), JInMemoryValue::fromCpp(value));
+  }
+  bool JHybridReactNativeDeviceUtilsSpec::removeInMemoryValue(const std::string& key) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* key */)>("removeInMemoryValue");
+    auto __result = method(_javaPart, jni::make_jstring(key));
+    return static_cast<bool>(__result);
+  }
+  bool JHybridReactNativeDeviceUtilsSpec::setInMemoryValueIfAbsent(const std::string& key, const std::variant<bool, std::string, double>& value) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* key */, jni::alias_ref<JInMemoryValue> /* value */)>("setInMemoryValueIfAbsent");
+    auto __result = method(_javaPart, jni::make_jstring(key), JInMemoryValue::fromCpp(value));
+    return static_cast<bool>(__result);
+  }
   std::shared_ptr<Promise<std::string>> JHybridReactNativeDeviceUtilsSpec::getAndClearColdStartLocalNotification() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAndClearColdStartLocalNotification");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridReactNativeDeviceUtilsSpec.hpp

@@ -70,6 +70,10 @@ namespace margelo::nitro::reactnativedeviceutils {
     std::shared_ptr<Promise<void>> saveDeviceToken(const std::string& token) override;
     std::shared_ptr<Promise<bool>> registerDeviceToken() override;
     std::shared_ptr<Promise<double>> getStartupTime() override;
+    std::optional<std::variant<bool, std::string, double>> getInMemoryValue(const std::string& key) override;
+    void setInMemoryValue(const std::string& key, const std::variant<bool, std::string, double>& value) override;
+    bool removeInMemoryValue(const std::string& key) override;
+    bool setInMemoryValueIfAbsent(const std::string& key, const std::variant<bool, std::string, double>& value) override;
     std::shared_ptr<Promise<std::string>> getAndClearColdStartLocalNotification() override;
     void exitApp() override;
     std::shared_ptr<Promise<WebViewPackageInfo>> getCurrentWebViewPackageInfo() override;

package/nitrogen/generated/android/c++/JInMemoryValue.cpp

@@ -0,0 +1,30 @@
+///
+/// JInMemoryValue.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JInMemoryValue.hpp"
+
+namespace margelo::nitro::reactnativedeviceutils {
+  /**
+   * Converts JInMemoryValue to std::variant<bool, std::string, double>
+   */
+  std::variant<bool, std::string, double> JInMemoryValue::toCpp() const {
+    if (isInstanceOf(JInMemoryValue_impl::First::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JInMemoryValue_impl::First*>(this)->getValue();
+      return static_cast<bool>(jniValue);
+    } else if (isInstanceOf(JInMemoryValue_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JInMemoryValue_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
+    } else if (isInstanceOf(JInMemoryValue_impl::Third::javaClassStatic())) {
+      // It's a `double`
+      auto jniValue = static_cast<const JInMemoryValue_impl::Third*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::reactnativedeviceutils

package/nitrogen/generated/android/c++/JInMemoryValue.hpp

@@ -0,0 +1,83 @@
+///
+/// JInMemoryValue.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "InMemoryValue".
+   */
+  class JInMemoryValue: public jni::JavaClass<JInMemoryValue> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/InMemoryValue;";
+
+    static jni::local_ref<JInMemoryValue> create_0(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JInMemoryValue(jboolean)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JInMemoryValue> create_1(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JInMemoryValue(jni::alias_ref<jni::JString>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JInMemoryValue> create_2(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JInMemoryValue(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JInMemoryValue> fromCpp(const std::variant<bool, std::string, double>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(std::get<0>(variant));
+        case 1: return create_1(jni::make_jstring(std::get<1>(variant)));
+        case 2: return create_2(std::get<2>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<bool, std::string, double> toCpp() const;
+  };
+
+  namespace JInMemoryValue_impl {
+    class First final: public jni::JavaClass<First, JInMemoryValue> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/InMemoryValue$First;";
+    
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JInMemoryValue> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/InMemoryValue$Second;";
+    
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Third final: public jni::JavaClass<Third, JInMemoryValue> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/InMemoryValue$Third;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JInMemoryValue_impl
+} // namespace margelo::nitro::reactnativedeviceutils

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/HybridReactNativeDeviceUtilsSpec.kt

@@ -99,6 +99,22 @@ abstract class HybridReactNativeDeviceUtilsSpec: HybridObject() {
   @Keep
   abstract fun getStartupTime(): Promise<Double>
   
+  @DoNotStrip
+  @Keep
+  abstract fun getInMemoryValue(key: String): InMemoryValue?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setInMemoryValue(key: String, value: InMemoryValue): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeInMemoryValue(key: String): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setInMemoryValueIfAbsent(key: String, value: InMemoryValue): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun getAndClearColdStartLocalNotification(): Promise<String>

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/InMemoryValue.kt

@@ -0,0 +1,75 @@
+///
+/// InMemoryValue.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativedeviceutils
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "Boolean | String | Double".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class InMemoryValue {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: Boolean): InMemoryValue()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): InMemoryValue()
+  @DoNotStrip
+  data class Third(@DoNotStrip val value: Double): InMemoryValue()
+
+  inline fun <reified T> asType(): T? {
+    return when (this) {
+      is First -> (value) as? T
+      is Second -> (value) as? T
+      is Third -> (value) as? T
+    }
+  }
+  inline fun <reified T> isType(): Boolean {
+    return asType<T>() != null
+  }
+  inline fun <R> match(first: (Boolean) -> R, second: (String) -> R, third: (Double) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+      is Third -> third(value)
+    }
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+  val isThird: Boolean
+    get() = this is Third
+
+  fun asFirstOrNull(): Boolean? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+  fun asThirdOrNull(): Double? {
+    val value = (this as? Third)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Boolean): InMemoryValue = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: String): InMemoryValue = Second(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Double): InMemoryValue = Third(value)
+  }
+}

package/nitrogen/generated/android/reactnativedeviceutils+autolinking.cmake

@@ -36,6 +36,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridReactNativeDeviceUtilsSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridReactNativeDeviceUtilsSpec.cpp
+  ../nitrogen/generated/android/c++/JInMemoryValue.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/ios/ReactNativeDeviceUtils-Swift-Cxx-Bridge.hpp

@@ -43,6 +43,7 @@ namespace ReactNativeDeviceUtils { class HybridReactNativeDeviceUtilsSpec_cxx; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 /**
@@ -337,6 +338,56 @@ namespace margelo::nitro::reactnativedeviceutils::bridge::swift {
     return Func_void_double_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::variant<bool, std::string, double>
+  /**
+   * Wrapper struct for `std::variant<bool, std::string, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_bool__std__string__double_ final {
+    std::variant<bool, std::string, double> variant;
+    std__variant_bool__std__string__double_(std::variant<bool, std::string, double> variant): variant(variant) { }
+    operator std::variant<bool, std::string, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline bool get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+    inline double get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+  };
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(bool value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(const std::string& value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(double value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<bool, std::string, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<bool, std::string, double>>`.
+   */
+  using std__optional_std__variant_bool__std__string__double__ = std::optional<std::variant<bool, std::string, double>>;
+  inline std::optional<std::variant<bool, std::string, double>> create_std__optional_std__variant_bool__std__string__double__(const std::variant<bool, std::string, double>& value) noexcept {
+    return std::optional<std::variant<bool, std::string, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_bool__std__string__double__(const std::optional<std::variant<bool, std::string, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<bool, std::string, double> get_std__optional_std__variant_bool__std__string__double__(const std::optional<std::variant<bool, std::string, double>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<WebViewPackageInfo>>
   /**
    * Specialized version of `std::shared_ptr<Promise<WebViewPackageInfo>>`.
@@ -507,6 +558,15 @@ namespace margelo::nitro::reactnativedeviceutils::bridge::swift {
     return Result<std::shared_ptr<Promise<double>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::optional<std::variant<bool, std::string, double>>>
+  using Result_std__optional_std__variant_bool__std__string__double___ = Result<std::optional<std::variant<bool, std::string, double>>>;
+  inline Result_std__optional_std__variant_bool__std__string__double___ create_Result_std__optional_std__variant_bool__std__string__double___(const std::optional<std::variant<bool, std::string, double>>& value) noexcept {
+    return Result<std::optional<std::variant<bool, std::string, double>>>::withValue(value);
+  }
+  inline Result_std__optional_std__variant_bool__std__string__double___ create_Result_std__optional_std__variant_bool__std__string__double___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::variant<bool, std::string, double>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<WebViewPackageInfo>>>
   using Result_std__shared_ptr_Promise_WebViewPackageInfo___ = Result<std::shared_ptr<Promise<WebViewPackageInfo>>>;
   inline Result_std__shared_ptr_Promise_WebViewPackageInfo___ create_Result_std__shared_ptr_Promise_WebViewPackageInfo___(const std::shared_ptr<Promise<WebViewPackageInfo>>& value) noexcept {

package/nitrogen/generated/ios/ReactNativeDeviceUtils-Swift-Cxx-Umbrella.hpp

@@ -41,6 +41,7 @@ namespace margelo::nitro::reactnativedeviceutils { struct WebViewPackageInfo; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 // C++ helpers for Swift

package/nitrogen/generated/ios/c++/HybridReactNativeDeviceUtilsSpecSwift.hpp

@@ -35,6 +35,7 @@ namespace margelo::nitro::reactnativedeviceutils { enum class InstallerPackageNa
 #include "LaunchOptions.hpp"
 #include <string>
 #include <optional>
+#include <variant>
 #include "WebViewPackageInfo.hpp"
 #include "GooglePlayServicesStatus.hpp"
 #include "AndroidChannel.hpp"
@@ -208,6 +209,36 @@ namespace margelo::nitro::reactnativedeviceutils {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::optional<std::variant<bool, std::string, double>> getInMemoryValue(const std::string& key) override {
+      auto __result = _swiftPart.getInMemoryValue(key);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setInMemoryValue(const std::string& key, const std::variant<bool, std::string, double>& value) override {
+      auto __result = _swiftPart.setInMemoryValue(key, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool removeInMemoryValue(const std::string& key) override {
+      auto __result = _swiftPart.removeInMemoryValue(key);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setInMemoryValueIfAbsent(const std::string& key, const std::variant<bool, std::string, double>& value) override {
+      auto __result = _swiftPart.setInMemoryValueIfAbsent(key, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::string>> getAndClearColdStartLocalNotification() override {
       auto __result = _swiftPart.getAndClearColdStartLocalNotification();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridReactNativeDeviceUtilsSpec.swift

@@ -29,6 +29,10 @@ public protocol HybridReactNativeDeviceUtilsSpec_protocol: HybridObject {
   func saveDeviceToken(token: String) throws -> Promise<Void>
   func registerDeviceToken() throws -> Promise<Bool>
   func getStartupTime() throws -> Promise<Double>
+  func getInMemoryValue(key: String) throws -> InMemoryValue?
+  func setInMemoryValue(key: String, value: InMemoryValue) throws -> Void
+  func removeInMemoryValue(key: String) throws -> Bool
+  func setInMemoryValueIfAbsent(key: String, value: InMemoryValue) throws -> Bool
   func getAndClearColdStartLocalNotification() throws -> Promise<String>
   func exitApp() throws -> Void
   func getCurrentWebViewPackageInfo() throws -> Promise<WebViewPackageInfo>

package/nitrogen/generated/ios/swift/HybridReactNativeDeviceUtilsSpec_cxx.swift

@@ -378,6 +378,98 @@ open class HybridReactNativeDeviceUtilsSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getInMemoryValue(key: std.string) -> bridge.Result_std__optional_std__variant_bool__std__string__double___ {
+    do {
+      let __result = try self.__implementation.getInMemoryValue(key: String(key))
+      let __resultCpp = { () -> bridge.std__optional_std__variant_bool__std__string__double__ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__variant_bool__std__string__double__({ () -> bridge.std__variant_bool__std__string__double_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_bool__std__string__double_(__value)
+              case .second(let __value):
+                return bridge.create_std__variant_bool__std__string__double_(std.string(__value))
+              case .third(let __value):
+                return bridge.create_std__variant_bool__std__string__double_(__value)
+            }
+          }().variant)
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__variant_bool__std__string__double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__variant_bool__std__string__double___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setInMemoryValue(key: std.string, value: bridge.std__variant_bool__std__string__double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setInMemoryValue(key: String(key), value: { () -> InMemoryValue in
+        let __variant = value
+        switch __variant.index() {
+          case 0:
+            let __actual = __variant.get_0()
+            return .first(__actual)
+          case 1:
+            let __actual = __variant.get_1()
+            return .second(String(__actual))
+          case 2:
+            let __actual = __variant.get_2()
+            return .third(__actual)
+          default:
+            fatalError("Variant can never have index \(__variant.index())!")
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeInMemoryValue(key: std.string) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.removeInMemoryValue(key: String(key))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setInMemoryValueIfAbsent(key: std.string, value: bridge.std__variant_bool__std__string__double_) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setInMemoryValueIfAbsent(key: String(key), value: { () -> InMemoryValue in
+        let __variant = value
+        switch __variant.index() {
+          case 0:
+            let __actual = __variant.get_0()
+            return .first(__actual)
+          case 1:
+            let __actual = __variant.get_1()
+            return .second(String(__actual))
+          case 2:
+            let __actual = __variant.get_2()
+            return .third(__actual)
+          default:
+            fatalError("Variant can never have index \(__variant.index())!")
+        }
+      }())
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getAndClearColdStartLocalNotification() -> bridge.Result_std__shared_ptr_Promise_std__string___ {
     do {

package/nitrogen/generated/ios/swift/InMemoryValue.swift

@@ -0,0 +1,32 @@
+///
+/// InMemoryValue.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `boolean | string | number`
+ */
+@frozen
+public enum InMemoryValue {
+  case first(Bool)
+  case second(String)
+  case third(Double)
+}
+
+public extension InMemoryValue {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+      case .third(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}

package/nitrogen/generated/shared/c++/HybridReactNativeDeviceUtilsSpec.cpp

@@ -30,6 +30,10 @@ namespace margelo::nitro::reactnativedeviceutils {
       prototype.registerHybridMethod("saveDeviceToken", &HybridReactNativeDeviceUtilsSpec::saveDeviceToken);
       prototype.registerHybridMethod("registerDeviceToken", &HybridReactNativeDeviceUtilsSpec::registerDeviceToken);
       prototype.registerHybridMethod("getStartupTime", &HybridReactNativeDeviceUtilsSpec::getStartupTime);
+      prototype.registerHybridMethod("getInMemoryValue", &HybridReactNativeDeviceUtilsSpec::getInMemoryValue);
+      prototype.registerHybridMethod("setInMemoryValue", &HybridReactNativeDeviceUtilsSpec::setInMemoryValue);
+      prototype.registerHybridMethod("removeInMemoryValue", &HybridReactNativeDeviceUtilsSpec::removeInMemoryValue);
+      prototype.registerHybridMethod("setInMemoryValueIfAbsent", &HybridReactNativeDeviceUtilsSpec::setInMemoryValueIfAbsent);
       prototype.registerHybridMethod("getAndClearColdStartLocalNotification", &HybridReactNativeDeviceUtilsSpec::getAndClearColdStartLocalNotification);
       prototype.registerHybridMethod("exitApp", &HybridReactNativeDeviceUtilsSpec::exitApp);
       prototype.registerHybridMethod("getCurrentWebViewPackageInfo", &HybridReactNativeDeviceUtilsSpec::getCurrentWebViewPackageInfo);

package/nitrogen/generated/shared/c++/HybridReactNativeDeviceUtilsSpec.hpp

@@ -35,6 +35,8 @@ namespace margelo::nitro::reactnativedeviceutils { enum class InstallerPackageNa
 #include "UserInterfaceStyle.hpp"
 #include "LaunchOptions.hpp"
 #include <string>
+#include <variant>
+#include <optional>
 #include "WebViewPackageInfo.hpp"
 #include "GooglePlayServicesStatus.hpp"
 #include "AndroidChannel.hpp"
@@ -87,6 +89,10 @@ namespace margelo::nitro::reactnativedeviceutils {
       virtual std::shared_ptr<Promise<void>> saveDeviceToken(const std::string& token) = 0;
       virtual std::shared_ptr<Promise<bool>> registerDeviceToken() = 0;
       virtual std::shared_ptr<Promise<double>> getStartupTime() = 0;
+      virtual std::optional<std::variant<bool, std::string, double>> getInMemoryValue(const std::string& key) = 0;
+      virtual void setInMemoryValue(const std::string& key, const std::variant<bool, std::string, double>& value) = 0;
+      virtual bool removeInMemoryValue(const std::string& key) = 0;
+      virtual bool setInMemoryValueIfAbsent(const std::string& key, const std::variant<bool, std::string, double>& value) = 0;
       virtual std::shared_ptr<Promise<std::string>> getAndClearColdStartLocalNotification() = 0;
       virtual void exitApp() = 0;
       virtual std::shared_ptr<Promise<WebViewPackageInfo>> getCurrentWebViewPackageInfo() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-device-utils",
-  "version": "3.0.177",
+  "version": "3.0.178",
   "description": "Native device, launch, system appearance and boot recovery utilities for OneKey",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/ReactNativeDeviceUtils.nitro.ts

@@ -1,6 +1,8 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 
 
+export type InMemoryValue = string | boolean | number;
+
 export type UserInterfaceStyle = 'light' | 'dark' | 'unspecified';
 
 export type AndroidChannel =
@@ -73,6 +75,11 @@ export interface ReactNativeDeviceUtils
   saveDeviceToken(token: string): Promise<void>;
   registerDeviceToken(): Promise<boolean>;
   getStartupTime(): Promise<number>;
+  // Process-owned primitive Map, shared by all runtimes and never persisted.
+  getInMemoryValue(key: string): InMemoryValue | undefined;
+  setInMemoryValue(key: string, value: InMemoryValue): void;
+  removeInMemoryValue(key: string): boolean;
+  setInMemoryValueIfAbsent(key: string, value: InMemoryValue): boolean;
   // Returns the JSON userInfo of a LOCAL notification the user tapped to launch
   // the (killed) app, then clears it so it is delivered exactly once. Empty
   // string when there is none. iOS-only meaningful; Android returns "".