chore: revamp

Author: YogendraShelke

.gitignore

@@ -90,3 +90,5 @@ lib/
 
 # Fastlane.swift runner binary
 **/fastlane/FastlaneRunner
+
+.claude/

android/src/main/java/com/facebook/react/devsupport/DevInternalSettings.kt

@@ -21,7 +21,7 @@ import com.mendix.mendixnative.react.clearCachedReactNativeDevBundle
 import com.mendix.mendixnative.react.clearData
 import com.mendix.mendixnative.react.closeSqlDatabaseConnection
 import com.mendix.mendixnative.react.toggleElementInspector
-import com.mendixnative.MendixNativeModule
+import com.mendix.mendixnative.react.NativeReloadHandler
 
 class MendixInitializer(
   private val context: Activity,
@@ -70,7 +70,9 @@ class MendixInitializer(
     devMenuTouchEventHandler =
       DevMenuTouchEventHandler(object : DevMenuTouchEventHandler.DevMenuTouchListener {
         override fun onTap() {
-          reactNativeHost.typeSafeNativeModule<MendixNativeModule>()?.reloadClientWithState()
+          reactNativeHost.reactApplicationContext()?.let {
+            NativeReloadHandler(it).reload()
+          }
         }
 
         override fun onLongPress() {

android/src/main/java/com/facebook/react/devsupport/DevSupportManagerHelpers.kt

@@ -88,30 +88,63 @@ fun clearDataWithReactContext(applicationContext: Application, reactNativeHost:
 }
 
 fun deleteAppDatabaseAsync(reactContext: ReactContext?, cb: BooleanCallback) {
-  reactContext?.typeSafeNativeModule<OPSQLiteModule>()?.let {
-    it.deleteAllDBs()
-    cb(true)
-  } ?: cb(false)
+  val opSQLiteModule = reactContext?.getNativeModule(OPSQLiteModule::class.java)
+  if (opSQLiteModule != null) {
+    try {
+      opSQLiteModule.deleteAllDBs()
+      cb(true)
+    } catch (e: Exception) {
+      Log.e("ClearData", "Failed to delete databases: ${e.message}")
+      cb(false)
+    }
+  } else {
+    cb(false)
+  }
 }
 
+/**
+ * Clears all AsyncStorage data.
+ *
+ * Note: Previous implementation only checked module availability without clearing.
+ * This now actually clears the storage using AsyncStorageModule.clear().
+ */
 fun clearAsyncStorage(reactNativeHost: ReactNativeHost): Boolean {
-  val module = reactNativeHost.typeSafeNativeModule<AsyncStorageModule>()
-  if (module != null) {
-    return true
-  } else {
-    return false
+  val asyncStorageModule = reactNativeHost.reactContext()?.getNativeModule(AsyncStorageModule::class.java)
+  if (asyncStorageModule != null) {
+    try {
+      // Clear AsyncStorage synchronously - clear() expects a callback but we're using fire-and-forget
+      asyncStorageModule.clear { error ->
+        if (error != null) {
+          Log.e("ClearData", "AsyncStorage clear error: $error")
+        }
+      }
+      return true
+    } catch (e: Exception) {
+      Log.e("ClearData", "Failed to clear AsyncStorage: ${e.message}")
+      return false
+    }
   }
+  return false
 }
 
 fun clearSecureStorage(context: Context?): Boolean =
   context?.let { MendixEncryptedStorage.getMendixEncryptedStorage(it).clear() } ?: false
 
-fun clearCookiesAsync(reactContext: ReactContext?, cb: (success: Boolean) -> Unit) =
-  reactContext?.typeSafeNativeModule<NetworkingModule>()?.let { module ->
-    module.clearCookies {
-      cb(it[0] as Boolean)
+fun clearCookiesAsync(reactContext: ReactContext?, cb: (success: Boolean) -> Unit) {
+  val networkingModule = reactContext?.getNativeModule(NetworkingModule::class.java)
+  if (networkingModule != null) {
+    try {
+      networkingModule.clearCookies { result ->
+        cb(result[0] as Boolean)
+      }
+    } catch (e: Exception) {
+      Log.e("ClearData", "Failed to clear cookies: ${e.message}")
+      cb(false)
     }
-  } ?: cb(false)
+  } else {
+    cb(false)
+  }
+}
 
 fun clearCachedReactNativeDevBundle(applicationContext: Application) {
   try {

android/src/main/java/com/mendix/mendixnative/MendixInitializer.kt

@@ -1,8 +1,21 @@
 package com.mendix.mendixnative.react
 
+import android.util.Log
 import com.facebook.react.bridge.ReactContext
 import com.op.sqlite.OPSQLiteModule
 
+/**
+ * Closes all SQLite database connections.
+ *
+ * This is called during app shutdown to gracefully close database connections.
+ */
 fun closeSqlDatabaseConnection(reactContext: ReactContext?) {
-  reactContext?.typeSafeNativeModule<OPSQLiteModule>()?.closeAllConnections()
+  val opSQLiteModule = reactContext?.getNativeModule(OPSQLiteModule::class.java)
+  if (opSQLiteModule != null) {
+    try {
+      opSQLiteModule.closeAllConnections()
+    } catch (e: Exception) {
+      Log.e("CloseApp", "Failed to close database connections: ${e.message}")
+    }
+  }
 }

android/src/main/java/com/mendix/mendixnative/react/ClearData.kt

@@ -3,16 +3,22 @@ package com.mendix.mendixnative.react
 import com.facebook.common.logging.FLog
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.ExceptionsManagerModule
 
+/**
+ * Handles JavaScript exceptions by reporting them to React Native's ExceptionsManager.
+ *
+ * This bridges JavaScript errors to the native exception handling system.
+ */
 class NativeErrorHandler(val reactContext: ReactApplicationContext) {
     fun handle(message: String?, stackTrace: ReadableArray?) {
-        reactContext.typeSafeNativeModule<ExceptionsManagerModule>()?.reportSoftException(message, stackTrace, 0.0)
-        // updateExceptionMessage is not available in RN 0.77.1
+        // Use typed module access instead of generic typeSafeNativeModule
+        val exceptionsManagerModule = reactContext.getNativeModule(ExceptionsManagerModule::class.java)
+        exceptionsManagerModule?.reportSoftException(message, stackTrace, 0.0)
+
+        // Note: updateExceptionMessage is not available in RN 0.77.1+
         // ref: https://github.com/facebook/react-native/commit/4f47439a02183205ff6f68b1fc3bc392e78e4cb4
-        // exceptionsManagerModule.updateExceptionMessage(message, stackTrace, 0);
+
         FLog.e(javaClass, "Received JS exception: $message")
     }
 }

android/src/main/java/com/mendix/mendixnative/react/CloseApp.kt

@@ -30,7 +30,7 @@ class NativeFsModule(private val reactContext: ReactApplicationContext) {
 
   fun save(blob: ReadableMap, filePath: String, promise: Promise) {
     val blobModule = reactContext.getNativeModule<BlobModule?>(BlobModule::class.java)
-    val blobId: String = blob.getString("blobId") ?: run {""
+    val blobId: String = blob.getString("blobId") ?: run {
       promise.reject(ERROR_INVALID_BLOB, "The specified blob is invalid")
       return
     }

android/src/main/java/com/mendix/mendixnative/react/NativeErrorHandler.kt

@@ -1,10 +1,16 @@
 package com.mendix.mendixnative.util;
 
-import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 
+/**
+ * Minimal reflection utilities for accessing React Native private fields.
+ *
+ * **Usage:** Only used by MendixShakeDetector to swap React Native's shake detector.
+ * There is no public React Native API for this functionality.
+ *
+ * **Note:** Reflection should be avoided where possible. This class is kept minimal
+ * and only exposes methods that are actively used.
+ */
 public class ReflectionUtils {
     private static Field findDeclaredField(Class<?> objectClass, String... fieldNames) {
         NoSuchFieldException lastException = null;
@@ -20,95 +26,27 @@ private static Field findDeclaredField(Class<?> objectClass, String... fieldName
         throw new RuntimeException(lastException);
     }
 
-    public static ConstructorWrapper findConstructor(String className, Class<?>... parameterTypes) {
-        try {
-            Constructor constructor = Class.forName(className).getDeclaredConstructor(parameterTypes);
-            constructor.setAccessible(true);
-            return new ConstructorWrapper(constructor);
-        } catch (ClassNotFoundException | NoSuchMethodException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    // TODO: replace this with a lambda after upgrading to Java 8
-    public static class ConstructorWrapper {
-        private final Constructor constructor;
-
-        ConstructorWrapper(Constructor constructor) {
-            this.constructor = constructor;
-        }
-
-        public <T> T newInstance(Object... args) {
-            try {
-                return (T) constructor.newInstance(args);
-            } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    public static MethodWrapper findMethod(Object object, String methodName, Class<?>... parameterTypes) {
-        try {
-            Method method = object.getClass().getDeclaredMethod(methodName, parameterTypes);
-            method.setAccessible(true);
-            return new MethodWrapper(method, object);
-        } catch (NoSuchMethodException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    // TODO: replace this with a lambda after upgrading to Java 8
-    public static class MethodWrapper {
-        private final Method method;
-        private final Object object;
-
-        MethodWrapper(Method method, Object object) {
-            this.method = method;
-            this.object = object;
-        }
-
-        public void invoke(Object... args) {
-            try {
-                method.invoke(object, args);
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    public static void setFieldOfSuperclass(Object object, String fieldName, Object value) {
-        setFieldOfSuperclass(object, value, fieldName);
-    }
-
+    /**
+     * Sets a field on the superclass of the given object.
+     * Tries multiple field names to handle React Native version differences.
+     *
+     * @param object The object whose superclass field should be set
+     * @param value The value to set
+     * @param fieldNames Field names to try (in order of preference)
+     */
     public static void setFieldOfSuperclass(Object object, Object value, String... fieldNames) {
         Field field = findDeclaredField(object.getClass().getSuperclass(), fieldNames);
         setField(object, field, value);
     }
 
-    public static void setField(Object object, String fieldName, Object value) {
-        try {
-            Field field = object.getClass().getDeclaredField(fieldName);
-            setField(object, field, value);
-        } catch (NoSuchFieldException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    private static void setField(Object object, Field field, Object value) {
-        try {
-            field.setAccessible(true);
-            field.set(object, value);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        } finally {
-            field.setAccessible(false);
-        }
-    }
-
-    public static <T> T getFieldOfSuperclass(Object object, String fieldName) {
-        return getFieldOfSuperclass(object, new String[] { fieldName });
-    }
-
+    /**
+     * Gets a field from the superclass of the given object.
+     * Tries multiple field names to handle React Native version differences.
+     *
+     * @param object The object whose superclass field should be retrieved
+     * @param fieldNames Field names to try (in order of preference)
+     * @return The field value
+     */
     public static <T> T getFieldOfSuperclass(Object object, String... fieldNames) {
         try {
             Field field = findDeclaredField(object.getClass().getSuperclass(), fieldNames);
@@ -119,14 +57,14 @@ public static <T> T getFieldOfSuperclass(Object object, String... fieldNames) {
         }
     }
 
-    public static <T> T getField(Object object, String fieldName) {
+    private static void setField(Object object, Field field, Object value) {
         try {
-            Field field = object.getClass().getDeclaredField(fieldName);
             field.setAccessible(true);
-            return (T) field.get(object);
-        } catch (NoSuchFieldException | IllegalAccessException | ClassCastException e) {
+            field.set(object, value);
+        } catch (IllegalAccessException e) {
             throw new RuntimeException(e);
+        } finally {
+            field.setAccessible(false);
         }
     }
-
 }