@appspacer/react-native 1.0.0

package/android/src/main/java/com/appspacer/AppSpacerModule.java

@@ -0,0 +1,731 @@
+package com.appspacer;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+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 com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.security.MessageDigest;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.UUID;
+import org.json.JSONObject;
+import org.json.JSONArray;
+import java.nio.charset.StandardCharsets;
+
+import android.content.SharedPreferences;
+import android.content.Context;
+import android.util.Log;
+
+public class AppSpacerModule extends ReactContextBaseJavaModule {
+
+    private static final String MODULE_NAME = "AppSpacerModule";
+    private static final String TAG = "AppSpacerModule";
+    private static final String PREFS_NAME = "AppSpacerPrefs";
+    private static final String KEY_PACKAGE_INFO = "packageInfo";
+    private static final String KEY_PREVIOUS_PACKAGE_INFO = "appspacer_previous_package_info";
+    private static final String KEY_BOOT_STATUS = "bootStatus"; // "SUCCESS" or "PENDING"
+    private static final String KEY_BOOT_COUNT = "bootCount";
+    
+    private static final String OTA_DIR = "AppSpacerOTA";
+
+    private final ReactApplicationContext reactContext;
+
+    public AppSpacerModule(ReactApplicationContext context) {
+        super(context);
+        this.reactContext = context;
+        
+        // Initialize Native Crash Handler automatically
+        AppSpacerCrashHandler.init(context);
+        
+        // Restore user identity if it exists
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String userId = prefs.getString("userId", null);
+        String userMetadata = prefs.getString("userMetadata", null);
+        if (userId != null) {
+            AppSpacerCrashHandler.setUserIdentity(userId, userMetadata);
+        }
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    // ─── Helpers ──────────────────────────────────────────────
+
+    private void sendDownloadProgress(double progress) {
+        WritableMap params = Arguments.createMap();
+        params.putDouble("progress", progress);
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("AppSpacerDownloadProgress", params);
+        } catch (Exception e) {
+            // JS not ready yet — ignore
+        }
+    }
+
+    private static File getOtaRootDir(Context context) {
+        return new File(context.getFilesDir(), OTA_DIR);
+    }
+
+    // ─── OTA Storage ─────────────────────────────────────────
+
+    @ReactMethod
+    public void getOtaStoragePath(Promise promise) {
+        try {
+            File otaDir = getOtaRootDir(reactContext);
+            if (!otaDir.exists()) {
+                otaDir.mkdirs();
+            }
+            promise.resolve(otaDir.getAbsolutePath());
+        } catch (Exception e) {
+            promise.reject("ERR_CREATE_DIR", "Failed to create OTA directory", e);
+        }
+    }
+
+    // ─── Download with Progress ──────────────────────────────
+
+    @ReactMethod
+    public void downloadPackage(String urlString, String destPath, Promise promise) {
+        new Thread(() -> {
+            HttpURLConnection connection = null;
+            try {
+                URL url = new URL(urlString);
+                connection = (HttpURLConnection) url.openConnection();
+                connection.setRequestMethod("GET");
+                connection.setConnectTimeout(15000);
+                connection.setReadTimeout(30000);
+                connection.connect();
+
+                int responseCode = connection.getResponseCode();
+                if (responseCode < 200 || responseCode >= 300) {
+                    promise.reject("ERR_HTTP", "Server returned HTTP " + responseCode);
+                    return;
+                }
+
+                long totalBytes = connection.getContentLength();
+                File destFile = new File(destPath, "update.zip");
+                if (destFile.exists()) {
+                    destFile.delete();
+                }
+
+                try (InputStream inputStream = connection.getInputStream();
+                     FileOutputStream outputStream = new FileOutputStream(destFile)) {
+                    byte[] buffer = new byte[8192];
+                    int bytesRead;
+                    long downloadedBytes = 0;
+                    long lastProgressTime = 0;
+
+                    while ((bytesRead = inputStream.read(buffer)) != -1) {
+                        outputStream.write(buffer, 0, bytesRead);
+                        downloadedBytes += bytesRead;
+
+                        // Emit progress at most every 250ms to avoid flooding the bridge
+                        long now = System.currentTimeMillis();
+                        if (totalBytes > 0 && (now - lastProgressTime) >= 250) {
+                            double progress = (double) downloadedBytes / totalBytes;
+                            sendDownloadProgress(progress);
+                            lastProgressTime = now;
+                        }
+                    }
+                }
+
+                // Final 100% progress
+                sendDownloadProgress(1.0);
+                promise.resolve(destFile.getAbsolutePath());
+            } catch (Exception e) {
+                promise.reject("ERR_DOWNLOAD", "Package download failed", e);
+            } finally {
+                if (connection != null) {
+                    connection.disconnect();
+                }
+            }
+        }).start();
+    }
+
+    // ─── Hash Verification ───────────────────────────────────
+
+    @ReactMethod
+    public void verifyHash(String filePath, String expectedHash, Promise promise) {
+        new Thread(() -> {
+            try {
+                MessageDigest digest = MessageDigest.getInstance("SHA-256");
+                try (InputStream fis = new FileInputStream(filePath)) {
+                    byte[] buffer = new byte[8192];
+                    int n;
+                    while ((n = fis.read(buffer)) != -1) {
+                        digest.update(buffer, 0, n);
+                    }
+                }
+                byte[] hashBytes = digest.digest();
+
+                StringBuilder hexString = new StringBuilder();
+                for (byte b : hashBytes) {
+                    String hex = Integer.toHexString(0xff & b);
+                    if (hex.length() == 1) hexString.append('0');
+                    hexString.append(hex);
+                }
+
+                boolean isValid = hexString.toString().equals(expectedHash);
+                promise.resolve(isValid);
+            } catch (Exception e) {
+                promise.reject("ERR_HASH", "Failed to compute hash", e);
+            }
+        }).start();
+    }
+
+    // ─── Unzip ───────────────────────────────────────────────
+
+    @ReactMethod
+    public void unzipPackage(String zipPath, String destDir, Promise promise) {
+        new Thread(() -> {
+            try {
+                File dir = new File(destDir);
+                if (!dir.exists()) dir.mkdirs();
+                String canonicalDest = dir.getCanonicalPath() + File.separator;
+
+                try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipPath))) {
+                    ZipEntry entry;
+                    byte[] buffer = new byte[8192];
+
+                    while ((entry = zis.getNextEntry()) != null) {
+                        File file = new File(dir, entry.getName());
+
+                        // Zip Slip protection
+                        if (!file.getCanonicalPath().startsWith(canonicalDest)) {
+                            throw new SecurityException("Zip entry outside target dir: " + entry.getName());
+                        }
+
+                        if (entry.isDirectory()) {
+                            file.mkdirs();
+                        } else {
+                            File parent = file.getParentFile();
+                            if (parent != null && !parent.exists()) parent.mkdirs();
+                            try (FileOutputStream fos = new FileOutputStream(file)) {
+                                int len;
+                                while ((len = zis.read(buffer)) > 0) {
+                                    fos.write(buffer, 0, len);
+                                }
+                            }
+                        }
+                        zis.closeEntry();
+                    }
+                }
+
+                // Clean up zip
+                new File(zipPath).delete();
+                promise.resolve(null);
+            } catch (SecurityException e) {
+                promise.reject("ERR_SECURITY", e.getMessage(), e);
+            } catch (Exception e) {
+                promise.reject("ERR_UNZIP", "Failed to unzip package", e);
+            }
+        }).start();
+    }
+
+    // ─── Install Update ──────────────────────────────────────
+
+    @ReactMethod
+    public void installUpdate(String unzippedDir, Promise promise) {
+        new Thread(() -> {
+            try {
+                // Verify the unzipped directory actually exists
+                File updateDir = new File(unzippedDir);
+                if (!updateDir.exists() || !updateDir.isDirectory()) {
+                    promise.reject("ERR_INSTALL", "Unzipped update directory does not exist");
+                    return;
+                }
+
+                SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+                String currentInfo = prefs.getString(KEY_PACKAGE_INFO, null);
+                
+                SharedPreferences.Editor editor = prefs.edit();
+                if (currentInfo != null) {
+                    editor.putString(KEY_PREVIOUS_PACKAGE_INFO, currentInfo);
+                }
+
+                editor.putString(KEY_BOOT_STATUS, "PENDING")
+                      .putInt(KEY_BOOT_COUNT, 0)
+                      .apply();
+
+                promise.resolve(null);
+            } catch (Exception e) {
+                promise.reject("ERR_INSTALL", "Failed to install update directory", e);
+            }
+        }).start();
+    }
+
+    // ─── Reload ──────────────────────────────────────────────
+
+    @ReactMethod
+    public void reloadApp() {
+        UiThreadUtil.runOnUiThread(() -> {
+            try {
+                ReactApplication application = (ReactApplication) reactContext.getApplicationContext();
+                
+                // 1. Try New Architecture (ReactHost)
+                try {
+                    com.facebook.react.ReactHost reactHost = application.getReactHost();
+                    if (reactHost != null) {
+                        reactHost.reload("AppSpacer Update");
+                        return;
+                    }
+                } catch (Throwable ignore) {}
+
+                // 2. Fallback: Restart the Activity via Intent
+                // This forces Android to call getJSBundleFile() again, picking up the new OTA bundle.
+                // recreateReactContextInBackground() alone does NOT reliably swap bundle paths.
+                try {
+                    android.app.Activity currentActivity = reactContext.getCurrentActivity();
+                    if (currentActivity != null) {
+                        android.content.Intent intent = currentActivity.getPackageManager()
+                            .getLaunchIntentForPackage(currentActivity.getPackageName());
+                        if (intent != null) {
+                            intent.addFlags(android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP | android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
+                            currentActivity.startActivity(intent);
+                            currentActivity.finish();
+                            // Kill the current process so the new Activity starts fresh
+                            android.os.Process.killProcess(android.os.Process.myPid());
+                            return;
+                        }
+                    }
+                } catch (Throwable e) {
+                    Log.w(MODULE_NAME, "Activity restart failed, falling back to recreateReactContextInBackground", e);
+                }
+
+                // 3. Last resort fallback to Classic Architecture (InstanceManager)
+                try {
+                    ReactInstanceManager instanceManager = application.getReactNativeHost().getReactInstanceManager();
+                    if (instanceManager != null) {
+                        instanceManager.recreateReactContextInBackground();
+                    }
+                } catch (Throwable ignore) {}
+            } catch (Exception e) {
+                Log.e(MODULE_NAME, "Failed to reload app", e);
+            }
+        });
+    }
+
+    // ─── Package Info ────────────────────────────────────────
+
+    @ReactMethod
+    public void getCurrentPackageHash(Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String infoStr = prefs.getString(KEY_PACKAGE_INFO, null);
+        if (infoStr != null) {
+            try {
+                JSONObject json = new JSONObject(infoStr);
+                promise.resolve(json.optString("hash", null));
+                return;
+            } catch (Exception e) {
+                // Ignore parsing errors
+            }
+        }
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void setCurrentPackageInfo(String info, Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        prefs.edit().putString(KEY_PACKAGE_INFO, info).apply();
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void getCurrentPackageInfo(Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        promise.resolve(prefs.getString(KEY_PACKAGE_INFO, null));
+    }
+
+    // ─── Boot Status & Rollback ──────────────────────────────
+
+    @ReactMethod
+    public void markSuccess(Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        prefs.edit()
+            .putString(KEY_BOOT_STATUS, "SUCCESS")
+            .putInt(KEY_BOOT_COUNT, 0)
+            .apply();
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void rollback(Promise promise) {
+        performRollback(reactContext);
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void getInstallId(Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String installId = prefs.getString("installId", null);
+        if (installId == null) {
+            installId = UUID.randomUUID().toString();
+            prefs.edit().putString("installId", installId).apply();
+        }
+        promise.resolve(installId);
+    }
+
+    // ─── Asset Resolution ────────────────────────────────────
+
+    @ReactMethod
+    public void getAssetSourceDirectory(Promise promise) {
+        String assetPath = getCustomAssetPath(reactContext);
+        promise.resolve(assetPath);
+    }
+
+    @Nullable
+    public static String getCustomAssetPath(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String infoStr = prefs.getString(KEY_PACKAGE_INFO, null);
+        if (infoStr == null) return null;
+
+        try {
+            JSONObject json = new JSONObject(infoStr);
+            String hash = json.optString("hash", null);
+            if (hash == null || hash.isEmpty()) return null;
+
+            File otaDir = getOtaRootDir(context);
+            File updateDir = new File(otaDir, "update_" + hash);
+            if (updateDir.exists() && updateDir.isDirectory()) {
+                return updateDir.getAbsolutePath();
+            }
+        } catch (Exception e) {
+            Log.e("AppSpacer", "Error resolving asset path", e);
+        }
+
+        return null;
+    }
+
+    // ─── Clear Old Updates ───────────────────────────────────
+
+    @ReactMethod
+    public void clearOldUpdates(Promise promise) {
+        new Thread(() -> {
+            try {
+                File otaDir = getOtaRootDir(reactContext);
+                if (!otaDir.exists()) {
+                    promise.resolve(0);
+                    return;
+                }
+
+                SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+
+                // Get active hash
+                String activeHash = null;
+                String infoStr = prefs.getString(KEY_PACKAGE_INFO, null);
+                if (infoStr != null) {
+                    try {
+                        JSONObject json = new JSONObject(infoStr);
+                        activeHash = json.optString("hash", null);
+                    } catch (Exception e) {}
+                }
+
+                // Get previous hash
+                String previousHash = null;
+                String prevInfoStr = prefs.getString(KEY_PREVIOUS_PACKAGE_INFO, null);
+                if (prevInfoStr != null) {
+                    try {
+                        JSONObject json = new JSONObject(prevInfoStr);
+                        previousHash = json.optString("hash", null);
+                    } catch (Exception e) {}
+                }
+
+                File[] children = otaDir.listFiles();
+                int removedCount = 0;
+                if (children != null) {
+                    for (File child : children) {
+                        String name = child.getName();
+                        if (!name.startsWith("update_")) continue;
+
+                        String hash = name.substring(7); // strip "update_"
+                        // Keep active and previous bundles
+                        if (hash.equals(activeHash)) continue;
+                        if (previousHash != null && hash.equals(previousHash)) continue;
+
+                        deleteRecursive(child);
+                        removedCount++;
+                    }
+                }
+
+                promise.resolve(removedCount);
+            } catch (Exception e) {
+                promise.reject("ERR_CLEAR", "Failed to clear old updates", e);
+            }
+        }).start();
+    }
+
+    // ─── Get Update Metadata ─────────────────────────────────
+
+    @ReactMethod
+    public void getUpdateMetadata(Promise promise) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        promise.resolve(prefs.getString(KEY_PACKAGE_INFO, null));
+    }
+
+    // ─── Rollback Logic ──────────────────────────────────────
+
+    private static void performRollback(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String previousInfo = prefs.getString(KEY_PREVIOUS_PACKAGE_INFO, null);
+        String currentInfo = prefs.getString(KEY_PACKAGE_INFO, null);
+        
+        SharedPreferences.Editor editor = prefs.edit();
+        if (previousInfo != null) {
+            editor.putString(KEY_PACKAGE_INFO, previousInfo);
+            editor.remove(KEY_PREVIOUS_PACKAGE_INFO);
+        } else {
+            editor.remove(KEY_PACKAGE_INFO);
+        }
+        editor.putString(KEY_BOOT_STATUS, "SUCCESS");
+        editor.apply();
+        
+        // Remove the corrupt update directory
+        if (currentInfo != null) {
+            try {
+                JSONObject json = new JSONObject(currentInfo);
+                String hash = json.optString("hash", null);
+                if (hash != null && !hash.isEmpty()) {
+                    File corruptDir = new File(getOtaRootDir(context), "update_" + hash);
+                    deleteRecursive(corruptDir);
+                }
+            } catch (Exception e) {}
+        }
+    }
+
+    private static void deleteRecursive(File fileOrDirectory) {
+        if (fileOrDirectory.isDirectory()) {
+            File[] children = fileOrDirectory.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    deleteRecursive(child);
+                }
+            }
+        }
+        fileOrDirectory.delete();
+    }
+
+    // ─── Bundle Path Resolution ──────────────────────────────
+
+    /**
+     * Call this from MainApplication to determine which bundle to load.
+     */
+    @Nullable
+    public static String getCustomBundlePath(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        String status = prefs.getString(KEY_BOOT_STATUS, "SUCCESS");
+
+        if ("PENDING".equals(status)) {
+            int bootCount = prefs.getInt(KEY_BOOT_COUNT, 0);
+            bootCount++;
+            prefs.edit().putInt(KEY_BOOT_COUNT, bootCount).apply();
+
+            if (bootCount > 1) {
+                Log.e("AppSpacer", "Crash detected on boot. Rolling back to previous bundle...");
+                performRollback(context);
+            }
+        }
+
+        String infoStr = prefs.getString(KEY_PACKAGE_INFO, null);
+        if (infoStr == null) return null;
+
+        try {
+            JSONObject json = new JSONObject(infoStr);
+            String hash = json.optString("hash", null);
+            if (hash == null || hash.isEmpty()) return null;
+
+            File otaDir = getOtaRootDir(context);
+            File currentBundle = new File(otaDir, "update_" + hash);
+            File customBundle = findBundleRecursive(currentBundle, "index.android.bundle");
+
+            if (customBundle != null && customBundle.exists()) {
+                return customBundle.getAbsolutePath();
+            }
+        } catch (Exception e) {
+            Log.e("AppSpacer", "Error parsing package info", e);
+        }
+
+        return null;
+    }
+
+    private static File findBundleRecursive(File dir, String bundleName) {
+        if (dir != null && dir.isDirectory()) {
+            File[] files = dir.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isFile() && file.getName().equals(bundleName)) {
+                        return file;
+                    }
+                }
+                for (File file : files) {
+                    if (file.isDirectory()) {
+                        File result = findBundleRecursive(file, bundleName);
+                        if (result != null) return result;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    // ─── Crash Analytics ─────────────────────────────────────
+
+    private static File getCrashDir(Context context) {
+        if (context == null) {
+            Log.e(MODULE_NAME, "Cannot get crash directory: context is null");
+            return null;
+        }
+        File dir = new File(context.getFilesDir(), "appspacer_crashes");
+        if (!dir.exists()) {
+            boolean created = dir.mkdirs();
+            if (created) {
+                Log.d(TAG, "Created crash directory: " + dir.getAbsolutePath());
+            } else {
+                Log.e(TAG, "Failed to create crash directory: " + dir.getAbsolutePath());
+            }
+        }
+        return dir;
+    }
+
+    public static void saveCrashToDiskSync(Context context, String id, String jsonPayload) {
+        try {
+            File crashDir = getCrashDir(context);
+            if (crashDir == null) return;
+            
+            File crashFile = new File(crashDir, id + ".json");
+            Log.d(MODULE_NAME, "Saving crash report to: " + crashFile.getAbsolutePath());
+            
+            try (FileOutputStream fos = new FileOutputStream(crashFile)) {
+                fos.write(jsonPayload.getBytes(StandardCharsets.UTF_8));
+                fos.flush();
+            }
+            Log.i(MODULE_NAME, "Crash report saved successfully: " + id);
+        } catch (Exception e) {
+            Log.e(MODULE_NAME, "Failed to save crash to disk: " + id, e);
+        }
+    }
+
+    @ReactMethod
+    public void setUserIdentity(String userId, String metadata) {
+        SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        prefs.edit()
+            .putString("userId", userId)
+            .putString("userMetadata", metadata)
+            .apply();
+        
+        // Also update the static handler for native crashes
+        AppSpacerCrashHandler.setUserIdentity(userId, metadata);
+    }
+
+    @ReactMethod
+    public void addBreadcrumb(String message) {
+        AppSpacerCrashHandler.addBreadcrumb(message);
+    }
+
+    @ReactMethod
+    public void saveCrashReport(String reportJson, Promise promise) {
+        try {
+            JSONObject json = new JSONObject(reportJson);
+            String id = json.getString("id");
+            
+            // Inject persisted user info if not already present
+            SharedPreferences prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+            String userId = prefs.getString("userId", null);
+            String userMetadata = prefs.getString("userMetadata", null);
+            
+            if (userId != null && !json.has("user_id")) {
+                json.put("user_id", userId);
+            }
+            if (userMetadata != null && !json.has("user_metadata")) {
+                try {
+                    json.put("user_metadata", new JSONObject(userMetadata));
+                } catch (Exception ignore) {}
+            }
+            
+            saveCrashToDiskSync(reactContext, id, json.toString());
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("ERR_CRASH_SAVE", "Failed to save crash report", e);
+        }
+    }
+
+    @ReactMethod
+    public void getPendingCrashReports(Promise promise) {
+        new Thread(() -> {
+            try {
+                File crashDir = getCrashDir(reactContext);
+                File[] files = crashDir.listFiles((dir, name) -> name.endsWith(".json"));
+                
+                JSONArray logs = new JSONArray();
+                if (files != null) {
+                    for (File f : files) {
+                        try (FileInputStream fis = new FileInputStream(f)) {
+                            byte[] data = new byte[(int) f.length()];
+                            fis.read(data);
+                            String content = new String(data, StandardCharsets.UTF_8);
+                            logs.put(new JSONObject(content));
+                        } catch (Exception ignore) {}
+                    }
+                }
+                
+                if (logs.length() == 0) {
+                    promise.resolve(null);
+                } else {
+                    promise.resolve(logs.toString());
+                }
+            } catch (Exception e) {
+                promise.reject("ERR_CRASH_READ", "Failed to read crash reports", e);
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void deleteCrashReport(String id, Promise promise) {
+        new Thread(() -> {
+            try {
+                File crashDir = getCrashDir(reactContext);
+                File crashFile = new File(crashDir, id + ".json");
+                if (crashFile.exists()) {
+                    crashFile.delete();
+                }
+                promise.resolve(null);
+            } catch (Exception e) {
+                promise.reject("ERR_CRASH_DELETE", "Failed to delete crash report", e);
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void testNativeCrash() {
+        // Trigger a runtime exception which will be caught by AppSpacerCrashHandler
+        throw new RuntimeException("Native crash test triggered from AppSpacer SDK");
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Required for NativeEventEmitter
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Required for NativeEventEmitter
+    }
+}