feat: migrate react-native-mmkv-storage to react-native-mmkv

__mocks__/react-native-mmkv.js

@@ -0,0 +1,97 @@
+// Mock for react-native-mmkv
+
+// Shared storage between instances with the same id
+const storageInstances = new Map();
+
+export const Mode = {
+	SINGLE_PROCESS: 1,
+	MULTI_PROCESS: 2
+};
+
+export class MMKV {
+	constructor(config = {}) {
+		const { id = 'default', mode, path } = config;
+		this.id = id;
+		this.mode = mode;
+		this.path = path;
+
+		// Share storage between instances with the same id
+		if (!storageInstances.has(this.id)) {
+			storageInstances.set(this.id, {
+				storage: new Map(),
+				listeners: []
+			});
+		}
+
+		const instance = storageInstances.get(this.id);
+		this.storage = instance.storage;
+		this.listeners = instance.listeners;
+	}
+
+	set(key, value) {
+		this.storage.set(key, value);
+		this.notifyListeners(key);
+	}
+
+	getString(key) {
+		const value = this.storage.get(key);
+		return typeof value === 'string' ? value : undefined;
+	}
+
+	getNumber(key) {
+		const value = this.storage.get(key);
+		return typeof value === 'number' ? value : undefined;
+	}
+
+	getBoolean(key) {
+		const value = this.storage.get(key);
+		return typeof value === 'boolean' ? value : undefined;
+	}
+
+	contains(key) {
+		return this.storage.has(key);
+	}
+
+	delete(key) {
+		const deleted = this.storage.delete(key);
+		if (deleted) {
+			this.notifyListeners(key);
+		}
+		return deleted;
+	}
+
+	getAllKeys() {
+		return Array.from(this.storage.keys());
+	}
+
+	clearAll() {
+		this.storage.clear();
+		// Notify about clear (pass undefined to indicate clear all)
+		this.notifyListeners(undefined);
+	}
+
+	addOnValueChangedListener(callback) {
+		this.listeners.push(callback);
+		return {
+			remove: () => {
+				const index = this.listeners.indexOf(callback);
+				if (index > -1) {
+					this.listeners.splice(index, 1);
+				}
+			}
+		};
+	}
+
+	notifyListeners(key) {
+		this.listeners.forEach((listener) => {
+			try {
+				listener(key);
+			} catch (error) {
+				console.error('Error in MMKV listener:', error);
+			}
+		});
+	}
+}
+
+// Export Configuration type for TypeScript
+export const Configuration = {};

android/app/build.gradle

@@ -151,6 +151,9 @@ dependencies {
     implementation "com.google.code.gson:gson:2.8.9"
     implementation "com.tencent:mmkv-static:1.2.10"
     implementation 'com.facebook.soloader:soloader:0.10.4'
+
+    // For SecureKeystore (EncryptedSharedPreferences)
+    implementation 'androidx.security:security-crypto:1.1.0-alpha06'
 }
 
 apply plugin: 'com.google.gms.google-services'

android/app/src/main/java/chat/rocket/reactnative/MainApplication.kt

@@ -26,7 +26,9 @@ import com.wix.reactnativenotifications.core.notification.IPushNotification
 import com.bugsnag.android.Bugsnag
 import expo.modules.ApplicationLifecycleDispatcher
 import chat.rocket.reactnative.networking.SSLPinningTurboPackage;
+import chat.rocket.reactnative.storage.MMKVReaderTurboPackage;
 import chat.rocket.reactnative.notification.CustomPushNotification;
+import com.tencent.mmkv.MMKV;
 
 open class MainApplication : Application(), ReactApplication, INotificationsApplication {
 
@@ -35,7 +37,9 @@ open class MainApplication : Application(), ReactApplication, INotificationsAppl
         override fun getPackages(): List<ReactPackage> =
             PackageList(this).packages.apply {
               add(SSLPinningTurboPackage())
+              add(MMKVReaderTurboPackage())
               add(WatermelonDBJSIPackage())
+              add(SecureStoragePackage())
             }
 
         override fun getJSMainModuleName(): String = "index"
@@ -53,6 +57,9 @@ open class MainApplication : Application(), ReactApplication, INotificationsAppl
     super.onCreate()
     SoLoader.init(this, OpenSourceMergedSoMapping)
     Bugsnag.start(this)
+
+    // Initialize MMKV before React Native starts
+    MMKV.initialize(this)
 
     if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
       // If you opted-in for the New Architecture, we load the native entry point for this app.

android/app/src/main/java/chat/rocket/reactnative/SecureStorage.java

@@ -0,0 +1,163 @@
+package chat.rocket.reactnative;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.security.keystore.KeyGenParameterSpec;
+import android.security.keystore.KeyProperties;
+import android.util.Base64;
+import android.util.Log;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import java.nio.charset.StandardCharsets;
+import java.security.KeyStore;
+import java.util.UUID;
+
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.GCMParameterSpec;
+
+public class SecureStorage extends ReactContextBaseJavaModule {
+    private static final String TAG = "SecureStorage";
+    private static final String KEYSTORE_PROVIDER = "AndroidKeyStore";
+    private static final String PREFS_NAME = "SecureStoragePrefs";
+    private static final String TRANSFORMATION = "AES/GCM/NoPadding";
+    private static final int GCM_TAG_LENGTH = 128;
+
+    private final ReactApplicationContext reactContext;
+
+    public SecureStorage(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "SecureStorage";
+    }
+
+    @ReactMethod
+    public void getSecureKey(String alias, Promise promise) {
+        try {
+            String value = getSecureKeyInternal(alias);
+            promise.resolve(value);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting secure key: " + alias, e);
+            promise.resolve(null);
+        }
+    }
+
+    @ReactMethod
+    public void setSecureKey(String alias, String value, Promise promise) {
+        try {
+            setSecureKeyInternal(alias, value);
+            promise.resolve(true);
+        } catch (Exception e) {
+            Log.e(TAG, "Error setting secure key: " + alias, e);
+            promise.reject("SET_SECURE_KEY_ERROR", e);
+        }
+    }
+
+    // Internal methods (can be called from Java)
+    public String getSecureKeyInternal(String alias) {
+        try {
+            SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+            String encryptedValue = prefs.getString(alias, null);
+
+            if (encryptedValue == null) {
+                return null;
+            }
+
+            // Decrypt the value
+            KeyStore keyStore = KeyStore.getInstance(KEYSTORE_PROVIDER);
+            keyStore.load(null);
+
+            if (!keyStore.containsAlias(alias)) {
+                return null;
+            }
+
+            SecretKey secretKey = (SecretKey) keyStore.getKey(alias, null);
+            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
+
+            // Split IV and encrypted data
+            byte[] combined = Base64.decode(encryptedValue, Base64.DEFAULT);
+            byte[] iv = new byte[12];
+            byte[] encrypted = new byte[combined.length - 12];
+            System.arraycopy(combined, 0, iv, 0, 12);
+            System.arraycopy(combined, 12, encrypted, 0, encrypted.length);
+
+            GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
+            cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);
+
+            byte[] decrypted = cipher.doFinal(encrypted);
+            return new String(decrypted, StandardCharsets.UTF_8);
+        } catch (Exception e) {
+            Log.e(TAG, "Error retrieving secure key", e);
+            return null;
+        }
+    }
+
+    public void setSecureKeyInternal(String alias, String value) throws Exception {
+        KeyStore keyStore = KeyStore.getInstance(KEYSTORE_PROVIDER);
+        keyStore.load(null);
+
+        // Create key if it doesn't exist
+        if (!keyStore.containsAlias(alias)) {
+            KeyGenerator keyGenerator = KeyGenerator.getInstance(
+                KeyProperties.KEY_ALGORITHM_AES, 
+                KEYSTORE_PROVIDER
+            );
+            keyGenerator.init(
+                new KeyGenParameterSpec.Builder(
+                    alias,
+                    KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT
+                )
+                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+                .setRandomizedEncryptionRequired(true)
+                .build()
+            );
+            keyGenerator.generateKey();
+        }
+
+        // Encrypt the value
+        SecretKey secretKey = (SecretKey) keyStore.getKey(alias, null);
+        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+
+        byte[] iv = cipher.getIV();
+        byte[] encrypted = cipher.doFinal(value.getBytes(StandardCharsets.UTF_8));
+
+        // Combine IV and encrypted data
+        byte[] combined = new byte[iv.length + encrypted.length];
+        System.arraycopy(iv, 0, combined, 0, iv.length);
+        System.arraycopy(encrypted, 0, combined, iv.length, encrypted.length);
+
+        String encryptedValue = Base64.encodeToString(combined, Base64.DEFAULT);
+
+        // Store in SharedPreferences
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        prefs.edit().putString(alias, encryptedValue).apply();
+    }
+
+    // Generate a secure key if it doesn't exist
+    public String getOrCreateSecureKey(String alias) {
+        String key = getSecureKeyInternal(alias);
+        if (key == null) {
+            // Generate a new random key
+            key = UUID.randomUUID().toString();
+            try {
+                setSecureKeyInternal(alias, key);
+            } catch (Exception e) {
+                Log.e(TAG, "Error creating secure key", e);
+                return null;
+            }
+        }
+        return key;
+    }
+}
+

android/app/src/main/java/chat/rocket/reactnative/SecureStoragePackage.java

@@ -0,0 +1,25 @@
+package chat.rocket.reactnative;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SecureStoragePackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new SecureStorage(reactContext));
+        return modules;
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}
+

android/app/src/main/java/chat/rocket/reactnative/notification/Ejson.java

@@ -5,7 +5,7 @@
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.Callback;
 
-import com.ammarahmed.mmkv.SecureKeystore;
+import chat.rocket.reactnative.SecureStorage;
 import com.tencent.mmkv.MMKV;
 import com.wix.reactnativenotifications.core.AppLifecycleFacade;
 import com.wix.reactnativenotifications.core.AppLifecycleFacadeHolder;
@@ -59,13 +59,15 @@ public Ejson() {
             try {
                 // Start MMKV container
                 MMKV.initialize(this.reactContext);
-                SecureKeystore secureKeystore = new SecureKeystore(this.reactContext);
+                SecureStorage secureStorage = new SecureStorage(this.reactContext);
 
-                // https://github.com/ammarahm-ed/react-native-mmkv-storage/blob/master/src/loader.js#L31
+                // https://github.com/ammarahm-ed/react-native-mmkv-storage/blob/master/src/loader.js#L31 
                 String alias = Utils.toHex("com.MMKV.default");
-
-                // Retrieve container password
-                String password = secureKeystore.getSecureKey(alias);
+
+                String password = secureStorage.getSecureKeyInternal(alias);
+
+
+                // Initialize MMKV (works with or without encryption)
                 mmkv = MMKV.mmkvWithID("default", MMKV.SINGLE_PROCESS_MODE, password);
             } catch (Exception e) {
                 Log.e("Ejson", "Failed to initialize MMKV: " + e.getMessage());