react-native-stallion 2.3.0-alpha.4 → 2.3.0-alpha.6

package/android/src/main/java/com/stallion/utils/StallionDeviceInfo.java

@@ -0,0 +1,83 @@
+package com.stallion.utils;
+
+import android.os.Build;
+
+import com.stallion.storage.StallionConfig;
+
+import org.json.JSONObject;
+
+import java.util.Locale;
+import java.util.TimeZone;
+
+public class StallionDeviceInfo {
+
+  /**
+   * Sample JSON contract for deviceMeta
+   * {
+   *   "osName": "Android",
+   *   "osVersion": "14",
+   *   "sdkInt": 34,
+   *   "manufacturer": "Google",
+   *   "brand": "google",
+   *   "model": "Pixel 7",
+   *   "device": "panther",
+   *   "product": "panther",
+   *   "hardware": "panther",
+   *   "locale": "en-US",
+   *   "localeLanguage": "en",
+   *   "localeCountry": "US",
+   *   "timezone": "America/Los_Angeles",
+   *   "timezoneOffsetMinutes": -420,
+   *   "isEmulator": false,
+   *   "projectId": "<project-id>",
+   *   "uid": "<device-uid>",
+   *   "appVersion": "1.2.3"
+   * }
+   */
+  public static JSONObject getDeviceMetaJson(StallionConfig config) {
+    JSONObject json = new JSONObject();
+    try {
+      json.put("osName", "Android");
+      json.put("osVersion", Build.VERSION.RELEASE != null ? Build.VERSION.RELEASE : "");
+      json.put("sdkInt", Build.VERSION.SDK_INT);
+      json.put("manufacturer", Build.MANUFACTURER != null ? Build.MANUFACTURER : "");
+      json.put("brand", Build.BRAND != null ? Build.BRAND : "");
+      json.put("model", Build.MODEL != null ? Build.MODEL : "");
+      json.put("device", Build.DEVICE != null ? Build.DEVICE : "");
+      json.put("product", Build.PRODUCT != null ? Build.PRODUCT : "");
+      json.put("hardware", Build.HARDWARE != null ? Build.HARDWARE : "");
+      Locale defaultLocale = Locale.getDefault();
+      json.put("locale", defaultLocale != null ? defaultLocale.toLanguageTag() : "");
+      json.put("localeLanguage", defaultLocale != null ? defaultLocale.getLanguage() : "");
+      json.put("localeCountry", defaultLocale != null ? defaultLocale.getCountry() : "");
+      TimeZone tz = TimeZone.getDefault();
+      json.put("timezone", tz != null ? tz.getID() : "");
+      json.put("timezoneOffsetMinutes", tz != null ? (tz.getOffset(System.currentTimeMillis()) / 60000) : 0);
+      json.put("isEmulator", isProbablyEmulator());
+      if (config != null) {
+        json.put("projectId", config.getProjectId());
+        json.put("uid", config.getUid());
+        json.put("appVersion", config.getAppVersion());
+      }
+    } catch (Exception ignored) { }
+    return json;
+  }
+
+  private static boolean isProbablyEmulator() {
+    String fingerprint = Build.FINGERPRINT;
+    String model = Build.MODEL;
+    String manufacturer = Build.MANUFACTURER;
+    String brand = Build.BRAND;
+    String device = Build.DEVICE;
+    String product = Build.PRODUCT;
+
+    if (fingerprint != null && (fingerprint.startsWith("generic") || fingerprint.startsWith("unknown"))) return true;
+    if (model != null && (model.contains("google_sdk") || model.contains("Emulator") || model.contains("Android SDK built for x86"))) return true;
+    if (manufacturer != null && manufacturer.contains("Genymotion")) return true;
+    if (brand != null && brand.startsWith("generic") && device != null && device.startsWith("generic")) return true;
+    if (product != null && product.equals("google_sdk")) return true;
+    return false;
+  }
+}
+
+

package/android/src/main/java/com/stallion/utils/StallionExceptionHandler.java

@@ -9,41 +9,64 @@ import com.stallion.storage.StallionStateManager;
 
 import org.json.JSONObject;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 public class StallionExceptionHandler {
 
   private static Thread.UncaughtExceptionHandler _androidUncaughtExceptionHandler;
   private static Thread _exceptionThread;
   private static Throwable _exceptionThrowable;
-  private static boolean isErrorBoundaryInitialized = false;
+  private static final AtomicBoolean isErrorBoundaryInitialized = new AtomicBoolean(false);
+  private static final AtomicBoolean isNativeSignalsInitialized = new AtomicBoolean(false);
+  private static final AtomicBoolean hasProcessedNativeCrashMarker = new AtomicBoolean(false);
+  private static final AtomicBoolean isRollbackPerformed = new AtomicBoolean(false);
 
   public static void initErrorBoundary() {
-    if (isErrorBoundaryInitialized) {
+    // Use compareAndSet to atomically check and set initialization flag
+    if (!isErrorBoundaryInitialized.compareAndSet(false, true)) {
       return; // Prevent multiple initializations
     }
-    isErrorBoundaryInitialized = true;
+
+    // Reset rollback flag when initializing exception handler
+    isRollbackPerformed.set(false);
 
     _androidUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
     Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
       _exceptionThread = thread;
       _exceptionThrowable = throwable;
 
-      // Safely trim the stack trace string
-      String stackTraceString = Log.getStackTraceString(throwable);
-      stackTraceString = stackTraceString.length() > 900
-        ? stackTraceString.substring(0, 900) + "..."
-        : stackTraceString;
-
-      StallionStateManager stateManager = StallionStateManager.getInstance();
-      StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
-
-      if (switchState == StallionMetaConstants.SwitchState.PROD) {
-        handleProdState(stackTraceString, stateManager);
-      } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
-        handleStageState(stackTraceString, stateManager);
-      } else {
+      try {
+        // Safely trim the stack trace string
+        String stackTraceString = Log.getStackTraceString(throwable);
+        stackTraceString = stackTraceString.length() > 900
+          ? stackTraceString.substring(0, 900) + "..."
+          : stackTraceString;
+
+        StallionStateManager stateManager = StallionStateManager.getInstance();
+        StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
+
+        if (switchState == StallionMetaConstants.SwitchState.PROD) {
+          handleProdState(stackTraceString, stateManager);
+        } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
+          handleStageState(stackTraceString, stateManager);
+        } else {
+          continueExceptionFlow();
+        }
+      } catch (Exception e) {
+        // If anything goes wrong in our handler, ensure we still chain to previous handler
         continueExceptionFlow();
       }
     });
+
+    // Initialize native signal handler once and process any prior crash marker
+    try {
+      if (isNativeSignalsInitialized.compareAndSet(false, true)) {
+        System.loadLibrary("stallion-crash");
+        String filesDir = StallionStateManager.getInstance().getStallionConfig().getFilesDirectory();
+        initNativeSignalHandler(filesDir);
+      }
+      processNativeCrashMarkerIfPresent();
+    } catch (Throwable ignored) {}
   }
 
   private static void emitException(String stackTraceString, String releaseHash, boolean isAutoRollback, boolean isProd) {
@@ -52,27 +75,43 @@ public class StallionExceptionHandler {
       syncErrorPayload.put("meta", stackTraceString);
       syncErrorPayload.put("releaseHash", releaseHash);
       syncErrorPayload.put("isAutoRollback", Boolean.toString(isAutoRollback));
+      StallionEventManager.getInstance().sendEvent(
+        isProd ?
+          StallionEventConstants.NativeProdEventTypes.EXCEPTION_PROD.toString()
+          : StallionEventConstants.NativeStageEventTypes.EXCEPTION_STAGE.toString(),
+        syncErrorPayload
+      );
     } catch (Exception ignored) { }
-    StallionEventManager.getInstance().sendEvent(
-      isProd ?
-        StallionEventConstants.NativeProdEventTypes.EXCEPTION_PROD.toString()
-        : StallionEventConstants.NativeStageEventTypes.EXCEPTION_STAGE.toString(),
-      syncErrorPayload
-    );
   }
 
   private static void handleProdState(String stackTraceString, StallionStateManager stateManager) {
     boolean isAutoRollback = !stateManager.getIsMounted();
     String currentHash = stateManager.stallionMeta.getHashAtCurrentProdSlot();
 
-    // Emit exception event
-    emitException(stackTraceString, currentHash, isAutoRollback, true);
+    // Only prevent multiple executions for auto rollback cases
+    // Launch crashes (when mounted) can continue to be registered
+    if (isAutoRollback) {
+      // Use compareAndSet to atomically check and set the flag
+      if (!isRollbackPerformed.compareAndSet(false, true)) {
+        // Flag was already true, skip duplicate rollback
+        continueExceptionFlow();
+        return;
+      }
+    }
+
+    // Emit exception event (wrap in try-catch to ensure chaining happens)
+    try {
+      emitException(stackTraceString, currentHash, isAutoRollback, true);
+    } catch (Exception ignored) { }
 
     // Perform rollback if auto-rollback is enabled
     if (isAutoRollback) {
-      StallionSlotManager.rollbackProd(true, stackTraceString);
+      try {
+        StallionSlotManager.rollbackProd(true, stackTraceString);
+      } catch (Exception ignored) { }
     }
 
+    // Always chain to previous handler, even if rollback or emit failed
     continueExceptionFlow();
   }
 
@@ -80,11 +119,29 @@ public class StallionExceptionHandler {
     boolean isAutoRollback = !stateManager.getIsMounted();
     String currentStageHash = stateManager.stallionMeta.getStageNewHash();
 
-    // Emit exception event
-    emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+    // Only prevent multiple executions for auto rollback cases
+    // Launch crashes (when mounted) can continue to be registered
+    if (isAutoRollback) {
+      // Use compareAndSet to atomically check and set the flag
+      if (!isRollbackPerformed.compareAndSet(false, true)) {
+        // Flag was already true, skip duplicate rollback
+        continueExceptionFlow();
+        return;
+      }
+    }
 
-    StallionSlotManager.rollbackStage();
+    // Emit exception event (wrap in try-catch to ensure chaining happens)
+    try {
+      emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+    } catch (Exception ignored) { }
 
+    if(isAutoRollback) {
+      try {
+        StallionSlotManager.rollbackStage();
+      } catch (Exception ignored) { }
+    }
+
+    // Always chain to previous handler, even if rollback or emit failed
     continueExceptionFlow();
   }
 
@@ -93,4 +150,80 @@ public class StallionExceptionHandler {
       _androidUncaughtExceptionHandler.uncaughtException(_exceptionThread, _exceptionThrowable);
     }
   }
+
+  private static void processNativeCrashMarkerIfPresent() {
+    try {
+      if (hasProcessedNativeCrashMarker.get()) { return; }
+      String filesDir = StallionStateManager.getInstance().getStallionConfig().getFilesDirectory();
+      java.io.File marker = new java.io.File(filesDir + "/stallion_crash.marker");
+      if (marker.exists()) {
+        StringBuilder sb = new StringBuilder();
+        try (java.io.BufferedReader br = new java.io.BufferedReader(new java.io.FileReader(marker))) {
+          String line;
+          while ((line = br.readLine()) != null) {
+            sb.append(line);
+          }
+        }
+        
+        String jsonContent = sb.toString();
+        String stackTraceString = "";
+        boolean isAutoRollback = false;
+        
+        try {
+          // Parse JSON from previous crash
+          JSONObject crashMarker = new JSONObject(jsonContent);
+          stackTraceString = crashMarker.optString("crashLog", "");
+          // Use the autoRollback flag that was determined at crash time (previous session)
+          isAutoRollback = crashMarker.optBoolean("isAutoRollback", false);
+        } catch (org.json.JSONException e) {
+          // Fallback for old format (non-JSON)
+          stackTraceString = jsonContent;
+          // Default to true for old format (conservative approach)
+          isAutoRollback = true;
+        }
+        
+        if (stackTraceString.length() > 900) {
+          stackTraceString = stackTraceString.substring(0, 900) + "...";
+        }
+
+        StallionStateManager stateManager = StallionStateManager.getInstance();
+        StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
+        if (switchState == StallionMetaConstants.SwitchState.PROD) {
+          String currentHash = stateManager.stallionMeta.getHashAtCurrentProdSlot();
+          // Use isAutoRollback from previous crash, not current session state
+          try {
+            emitException(stackTraceString, currentHash, isAutoRollback, true);
+          } catch (Exception ignored) { }
+          if (isAutoRollback) {
+            // Only prevent multiple executions for auto rollback cases
+            if (isRollbackPerformed.compareAndSet(false, true)) {
+              try {
+                StallionSlotManager.rollbackProd(true, stackTraceString);
+              } catch (Exception ignored) { }
+            }
+          }
+        } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
+          String currentStageHash = stateManager.stallionMeta.getStageNewHash();
+          // Use isAutoRollback from previous crash, not current session state
+          try {
+            emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+          } catch (Exception ignored) { }
+          if (isAutoRollback) {
+            // Only prevent multiple executions for auto rollback cases
+            if (isRollbackPerformed.compareAndSet(false, true)) {
+              try {
+                StallionSlotManager.rollbackStage();
+              } catch (Exception ignored) { }
+            }
+          }
+        }
+
+        // delete marker
+        StallionFileManager.deleteFileOrFolderSilently(marker);
+        hasProcessedNativeCrashMarker.set(true);
+      }
+    } catch (Exception ignored) {}
+  }
+
+  private static native void initNativeSignalHandler(String filesDir);
 }

package/ios/Stallion.xcodeproj/project.pbxproj

@@ -9,6 +9,7 @@
 /* Begin PBXBuildFile section */
 		5E555C0D2413F4C50049A1A2 /* Stallion.m in Sources */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* Stallion.m */; };
 		F4FF95D7245B92E800C19C63 /*  Stallion.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D6245B92E800C19C63 /*  Stallion.swift */; };
+		F4FF95DA245B92EB00C19C63 /* StallionDeviceInfo.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -28,6 +29,8 @@
 		B3E7B5891CC2AC0600A0062D /* Stallion.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Stallion.m; sourceTree = "<group>"; };
 		F4FF95D5245B92E700C19C63 /* Stallion-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Stallion-Bridging-Header.h"; sourceTree = "<group>"; };
 		F4FF95D6245B92E800C19C63 /* Stallion.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Stallion.swift; sourceTree = "<group>"; };
+		F4FF95D7245B92E900C19C63 /* StallionVersion.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "StallionVersion.h"; sourceTree = "<group>"; };
+		F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "StallionDeviceInfo.swift"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -53,8 +56,10 @@
 			isa = PBXGroup;
 			children = (
 				F4FF95D6245B92E800C19C63 /* Stallion.swift */,
+				F4FF95D9245B92EB00C19C63 /* StallionDeviceInfo.swift */,
 				B3E7B5891CC2AC0600A0062D /* Stallion.m */,
 				F4FF95D5245B92E700C19C63 /* Stallion-Bridging-Header.h */,
+				F4FF95D7245B92E900C19C63 /* StallionVersion.h */,
 				134814211AA4EA7D00B7C361 /* Products */,
 			);
 			sourceTree = "<group>";
@@ -117,6 +122,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				F4FF95D7245B92E800C19C63 /* Stallion.swift in Sources */,
+				F4FF95DA245B92EB00C19C63 /* StallionDeviceInfo.swift in Sources */,
 				B3E7B58A1CC2AC0600A0062D /* Stallion.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

package/ios/main/Stallion.swift

@@ -30,6 +30,14 @@ class Stallion: RCTEventEmitter {
     @objc func onLaunch(_ launchData: String) {
         stallionStateManager.isMounted = true
         checkPendingDownloads()
+        let currentReleaseHash = stallionStateManager.stallionMeta.getHashAtCurrentProdSlot()
+        if let currentReleaseHash = currentReleaseHash {
+            if !currentReleaseHash.isEmpty && stallionStateManager.stallionMeta.getSuccessfulLaunchCount(currentReleaseHash) == 0 {
+                emitInstallEvent(currentReleaseHash)
+            }
+            stallionStateManager.stallionMeta.markSuccessfulLaunch(currentReleaseHash)
+            stallionStateManager.syncStallionMeta()
+        }
     }
 
     private func checkPendingDownloads() {
@@ -153,5 +161,17 @@ class Stallion: RCTEventEmitter {
           RCTTriggerReloadCommandListeners("Stallion: Restart")
       }
   }
+  
+  private func emitInstallEvent(_ releaseHash: String) {
+      let eventPayload: [String: Any] = [
+          "releaseHash": releaseHash
+      ]
+      
+      Stallion.sendEventToRn(
+          eventName: StallionConstants.NativeEventTypesProd.INSTALLED_PROD,
+          eventBody: eventPayload as NSDictionary,
+          shouldCache: false
+      )
+  }
 }
 

package/ios/main/StallionConstants.swift

@@ -34,6 +34,7 @@ class StallionConstants {
         static let SecretKey = "secretKey"
     }
     static let PROGRESS_EVENT_THRESHOLD: Float = 0.05;
+    static let PROGRESS_THROTTLE_INTERVAL_MS: TimeInterval = 0.3; // 300ms
   
     static let PROD_DIRECTORY = "StallionProd"
     static let STAGE_DIRECTORY = "StallionStage"

package/ios/main/StallionDeviceInfo.swift

@@ -0,0 +1,105 @@
+//
+//  StallionDeviceInfo.swift
+//  react-native-stallion
+//
+//  Created by Thor963 on 29/01/25.
+//
+
+import Foundation
+import UIKit
+
+class StallionDeviceInfo {
+    
+    /**
+     * Sample JSON contract for deviceMeta
+     * {
+     *   "osName": "iOS",
+     *   "osVersion": "17.2",
+     *   "sdkInt": 17,
+     *   "manufacturer": "Apple",
+     *   "brand": "Apple",
+     *   "model": "iPhone 15 Pro",
+     *   "device": "iPhone16,1",
+     *   "product": "iPhone16,1",
+     *   "hardware": "iPhone16,1",
+     *   "locale": "en-US",
+     *   "localeLanguage": "en",
+     *   "localeCountry": "US",
+     *   "timezone": "America/Los_Angeles",
+     *   "timezoneOffsetMinutes": -420,
+     *   "isEmulator": false,
+     *   "projectId": "<project-id>",
+     *   "uid": "<device-uid>",
+     *   "appVersion": "1.2.3"
+     * }
+     */
+    static func getDeviceMetaJson(_ config: StallionConfig?) -> [String: Any] {
+        var json: [String: Any] = [:]
+        
+        // OS Information
+        json["osName"] = "iOS"
+        json["osVersion"] = UIDevice.current.systemVersion
+        json["sdkInt"] = Int(UIDevice.current.systemVersion.components(separatedBy: ".").first ?? "0") ?? 0
+        
+        // Device Information
+        json["manufacturer"] = "Apple"
+        json["brand"] = "Apple"
+        json["model"] = getDeviceModel()
+        json["device"] = getDeviceIdentifier()
+        json["product"] = getDeviceIdentifier()
+        json["hardware"] = getDeviceIdentifier()
+        
+        // Locale Information
+        let locale = Locale.current
+        json["locale"] = locale.identifier
+        json["localeLanguage"] = locale.languageCode ?? ""
+        json["localeCountry"] = locale.regionCode ?? ""
+        
+        // Timezone Information
+        let timezone = TimeZone.current
+        json["timezone"] = timezone.identifier
+        json["timezoneOffsetMinutes"] = timezone.secondsFromGMT() / 60
+        
+        // Emulator Detection
+        json["isEmulator"] = isProbablyEmulator()
+        
+        // Config Information
+        if let config = config {
+            json["projectId"] = config.projectId ?? ""
+            json["uid"] = config.uid ?? ""
+            json["appVersion"] = config.appVersion ?? ""
+        }
+        
+        return json
+    }
+    
+    private static func getDeviceModel() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let modelCode = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                ptr in String.init(validatingUTF8: ptr)
+            }
+        }
+        return modelCode ?? "Unknown"
+    }
+    
+    private static func getDeviceIdentifier() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let identifier = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                ptr in String.init(validatingUTF8: ptr)
+            }
+        }
+        return identifier ?? "Unknown"
+    }
+    
+    private static func isProbablyEmulator() -> Bool {
+        #if targetEnvironment(simulator)
+        return true
+        #else
+        return false
+        #endif
+    }
+}

package/ios/main/StallionEventHandler.m

@@ -7,6 +7,7 @@
 
 #import "StallionEventHandler.h"
 #import "StallionStateManager.h"
+#import "StallionVersion.h"
 
 #import <React/RCTBridge.h>
 #import <React/RCTEventDispatcher.h>
@@ -15,7 +16,7 @@
 static NSString *const STALLION_NATIVE_EVENT_NAME = @"STALLION_NATIVE_EVENT";
 static NSString *const EVENTS_KEY = @"stored_events";
 static NSInteger const MAX_BATCH_COUNT_SIZE = 9;
-static NSInteger const MAX_EVENT_STORAGE_LIMIT = 20;
+static NSInteger const MAX_EVENT_STORAGE_LIMIT = 60;
 
 @implementation StallionEventHandler
 
@@ -45,6 +46,7 @@ static NSInteger const MAX_EVENT_STORAGE_LIMIT = 20;
     mutablePayload[@"platform"] = @"ios";
     mutablePayload[@"appVersion"] = appVersion;
     mutablePayload[@"uid"] = uid;
+    mutablePayload[@"sdkVersion"] = STALLION_SDK_VERSION;
     // Store event locally
     [self storeEventLocally:uniqueId eventPayload:mutablePayload];
 }

package/ios/main/StallionExceptionHandler.h

@@ -12,6 +12,7 @@ NS_ASSUME_NONNULL_BEGIN
 @interface StallionExceptionHandler : NSObject
 
 + (void)initExceptionHandler;
++ (void)initJavaScriptExceptionHandler;
 
 @end