react-native-stallion 1.1.2 → 2.0.0-alpha.1

package/android/src/main/java/com/stallion/StallionSynManager.java

@@ -0,0 +1,142 @@
+package com.stallion;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.res.Resources;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import org.json.JSONObject;
+
+public class StallionSynManager {
+  public static void sync() {
+    new Thread(() -> {
+      try {
+        StallionStorage stallionStorage = StallionStorage.getInstance();
+        Context appContext = stallionStorage.mContext;
+        String parentPackageName= appContext.getPackageName();
+        PackageInfo pInfo = appContext.getPackageManager().getPackageInfo(parentPackageName, 0);
+        String appVersion = pInfo.versionName;
+        Resources res = appContext.getResources();
+        int stallionProjectIdRes = res.getIdentifier(StallionConstants.STALLION_PROJECT_ID_IDENTIFIER, "string", parentPackageName);
+        int stallionTokenRes = res.getIdentifier(StallionConstants.STALLION_APP_TOKEN_IDENTIFIER, "string", parentPackageName);
+        String projectId = appContext.getString(stallionProjectIdRes);
+        String appToken = appContext.getString(stallionTokenRes);
+        String platform = "android";
+        String currentProdSlot = stallionStorage.get(StallionConstants.CURRENT_PROD_SLOT_KEY);
+        String appliedBundleHash = stallionStorage.get(StallionConstants.PROD_DIRECTORY + currentProdSlot);
+        String sdkToken = stallionStorage.get(StallionConstants.STALLION_SDK_TOKEN_KEY);
+        JSONObject releaseMeta = StallionApiUtil.post(
+          StallionConstants.STALLION_API_BASE + StallionConstants.STALLION_INFO_API_PATH,
+          String.format(String.format("{\"appVersion\": \"%s\", \"platform\": \"%s\", \"projectId\": \"%s\", \"appliedBundleHash\": \"%s\" }", appVersion, platform, projectId, appliedBundleHash)),
+          appToken,
+          sdkToken
+        );
+        if(releaseMeta.optBoolean("success")) {
+          JSONObject data = releaseMeta.optJSONObject("data");
+          if(data == null) return;
+          JSONObject newReleaseData = data.optJSONObject("newBundleData");
+          JSONObject appliedReleaseData = data.optJSONObject("appliedBundleData");
+          if(appliedReleaseData != null) {
+            boolean isRolledBack = appliedReleaseData.optBoolean("isRolledBack");
+            String targetAppVersion = appliedReleaseData.optString("targetAppVersion");
+            if(isRolledBack && targetAppVersion.equals(appVersion)) {
+              StallionRollbackManager.rollbackProd(false);
+            }
+          }
+          if(newReleaseData != null) {
+            String newReleaseUrl = newReleaseData.optString("downloadUrl");
+            String newReleaseHash = newReleaseData.optString("checksum");
+            String lastRolledBackHash = stallionStorage.get(StallionConstants.LAST_ROLLED_BACK_RELEASE_HASH_KEY);
+            if(!newReleaseHash.equals(lastRolledBackHash)) {
+              stallionStorage.set(StallionConstants.NEW_RELEASE_HASH_ID, newReleaseHash);
+              stallionStorage.set(StallionConstants.NEW_RELEASE_URL_ID, newReleaseUrl);
+              checkAndDownload();
+            }
+          }
+        }
+      } catch (Exception e) {
+        WritableMap syncErrorPayload = Arguments.createMap();
+        syncErrorPayload.putString("error", e.toString().substring(0,100));
+        StallionEventEmitter.sendEvent(
+          StallionEventEmitter.getEventPayload(
+            StallionConstants.NativeEventTypesProd.SYNC_ERROR_PROD.toString(),
+            syncErrorPayload
+          )
+        );
+      }
+    }).start();
+  }
+
+  public static void checkAndDownload () {
+    StallionStorage stallionStorage = StallionStorage.getInstance();
+    Context appContext = stallionStorage.mContext;
+    String parentPackageName= appContext.getPackageName();
+    String newReleaseHash = stallionStorage.get(StallionConstants.NEW_RELEASE_HASH_ID);
+    String newReleaseUrl = stallionStorage.get(StallionConstants.NEW_RELEASE_URL_ID);
+    if(!newReleaseUrl.isEmpty() && !newReleaseHash.isEmpty()) {
+      Resources res = appContext.getResources();
+      int stallionProjectIdRes = res.getIdentifier(StallionConstants.STALLION_PROJECT_ID_IDENTIFIER, "string", parentPackageName);
+      int stallionTokenRes = res.getIdentifier(StallionConstants.STALLION_APP_TOKEN_IDENTIFIER, "string", parentPackageName);
+      String projectId = appContext.getString(stallionProjectIdRes);
+      String appToken = appContext.getString(stallionTokenRes);
+      stallionStorage.set(StallionConstants.NEW_RELEASE_HASH_ID, "");
+      stallionStorage.set(StallionConstants.NEW_RELEASE_URL_ID, "");
+      WritableMap newReleasePayload = Arguments.createMap();
+      newReleasePayload.putString("releaseHash", newReleaseHash);
+      StallionEventEmitter.sendEvent(
+        StallionEventEmitter.getEventPayload(
+          StallionConstants.NativeEventTypesProd.DOWNLOAD_STARTED_PROD.toString(),
+          newReleasePayload
+        )
+      );
+      StallionDownloadManager.downloadBundle(
+        newReleaseUrl + "?projectId=" + projectId,
+        appContext.getFilesDir().getAbsolutePath() + StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT,
+        "",
+        appToken,
+        new StallionDownloadCallback() {
+          @Override
+          public void onReject(String prefix, String error) {
+            WritableMap errorEventPayload = Arguments.createMap();
+            errorEventPayload.putString("releaseHash", newReleaseHash);
+            StallionEventEmitter.sendEvent(
+              StallionEventEmitter.getEventPayload(
+                StallionConstants.NativeEventTypesProd.DOWNLOAD_ERROR_PROD.toString(),
+                errorEventPayload
+              )
+            );
+          }
+
+          @Override
+          public void onSuccess(String successPayload) {
+            stallionStorage.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.TEMP_FOLDER_SLOT);
+            stallionStorage.set(StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, newReleaseHash);
+            WritableMap successEventPayload = Arguments.createMap();
+            successEventPayload.putString("releaseHash", newReleaseHash);
+            StallionEventEmitter.sendEvent(
+              StallionEventEmitter.getEventPayload(
+                StallionConstants.NativeEventTypesProd.DOWNLOAD_COMPLETE_PROD.toString(),
+                successEventPayload
+              )
+            );
+          }
+
+          @Override
+          public void onProgress(double downloadFraction) {
+            WritableMap progressEventPayload = Arguments.createMap();
+            progressEventPayload.putString("releaseHash", newReleaseHash);
+            progressEventPayload.putDouble("progress", downloadFraction);
+            StallionEventEmitter.sendEvent(
+              StallionEventEmitter.getEventPayload(
+                StallionConstants.NativeEventTypesProd.DOWNLOAD_PROGRESS_PROD.toString(),
+                progressEventPayload
+              )
+            );
+          }
+        }
+      );
+    }
+  }
+}

package/ios/main/Stallion-Bridging-Header.h

@@ -2,3 +2,7 @@
 #import <React/RCTViewManager.h>
 #import <React/RCTEventEmitter.h>
 #import <StallionErrorBoundary.h>
+#import <StallionEventManager.h>
+#import <StallionObjConstants.h>
+#import <StallionRollbackHandler.h>
+#import <StallionObjUtil.h>

package/ios/main/Stallion.m

@@ -3,15 +3,17 @@
 
 @interface RCT_EXTERN_MODULE(Stallion, NSObject)
 
+RCT_EXTERN_METHOD(onLaunch: (NSString *)launchMessage)
+RCT_EXTERN_METHOD(sync)
 RCT_EXTERN_METHOD(downloadPackage:(NSDictionary *)bundleInfo
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject
                   )
-
-RCT_EXTERN_METHOD(getStallionMeta: (RCTResponseSenderBlock)callback)
-RCT_EXTERN_METHOD(getApiKey: (RCTResponseSenderBlock)callback)
-RCT_EXTERN_METHOD(setApiKey: (NSString *)apiKey)
-RCT_EXTERN_METHOD(toggleStallionSwitch: (BOOL *)isOn)
+RCT_EXTERN_METHOD(getStorage: (NSString *)storageKey callback:(RCTResponseSenderBlock)callback)
+RCT_EXTERN_METHOD(getUniqueId: (RCTResponseSenderBlock)callback)
+RCT_EXTERN_METHOD(getProjectId: (RCTResponseSenderBlock)callback)
+RCT_EXTERN_METHOD(getAppToken: (RCTResponseSenderBlock)callback)
+RCT_EXTERN_METHOD(setStorage: (NSString *)storageKey value:(NSString *)value)
 
 + (BOOL)requiresMainQueueSetup
 {

package/ios/main/Stallion.swift

@@ -7,62 +7,103 @@ class Stallion: RCTEventEmitter {
     override init() {
         super.init()
         Stallion.shared = self
+        StallionSyncManager.sync()
+        NotificationCenter.default.addObserver(self, selector: #selector(appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
     }
-    
+  
     override func supportedEvents() -> [String]! {
-        return [StallionConstants.DOWNLOAD_PROGRESS_EVENT]
+      return [StallionConstants.STALLION_NATIVE_EVENT_NAME]
+    }
+  
+    @objc func appDidBecomeActive() {
+      StallionSyncManager.sync()
     }
     
-    @objc(downloadPackage:withResolver:withRejecter:)
+  @objc(downloadPackage:withResolver:withRejecter:)
     func downloadPackage(bundleInfo: NSDictionary, resolve: @escaping RCTPromiseResolveBlock,reject: @escaping RCTPromiseRejectBlock) -> Void {
-        guard let receivedBucketId = bundleInfo.value(forKey: StallionConstants.DownloadReqBodyKeys.BucketId) else {return}
-        guard var receiveDownloadUrl = bundleInfo.value(forKey: StallionConstants.DownloadReqBodyKeys.DownloadUrl) else {return}
-        let receivedVersion = bundleInfo.value(forKey: StallionConstants.DownloadReqBodyKeys.Version) as? Int ?? nil
-        var reqJson: [String: Any] = [
-            StallionConstants.DownloadReqBodyKeys.BucketId: receivedBucketId,
-            StallionConstants.DownloadReqBodyKeys.Platform: StallionConstants.PlatformValue,
-        ]
-        if (receivedVersion != nil) {
-            reqJson[StallionConstants.DownloadReqBodyKeys.Version] = receivedVersion
-        }
-        guard let fromUrl = URL(string: receiveDownloadUrl as? String ?? "") else { return }
+        let receivedDownloadUrl = (bundleInfo.value(forKey: StallionConstants.DownloadReqBodyKeys.DownloadUrl) as? String) ?? ""
+        let receivedReleaseHash = (bundleInfo.value(forKey: StallionConstants.DownloadReqBodyKeys.Hash) as? String) ?? ""
+        let stageDownloadEventBody = ["releaseHash": receivedReleaseHash]
+      
+        guard let fromUrl = URL(string: receivedDownloadUrl) else { return }
         
         do {
-                try StallionDownloader().load(
-                    url: fromUrl,
-                    reqBody: reqJson,
-                    resolve: resolve,
-                    reject: reject
-                )
+            try StallionDownloader().load(
+                url: fromUrl,
+                downloadPaths: [StallionConstants.STAGE_DIRECTORY, StallionConstants.TEMP_FOLDER_SLOT],
+                onProgress: {progress in
+                  StallionEventEmitter.sendEvent(eventType: StallionConstants.NativeEventTypesStage.DOWNLOAD_PROGRESS_STAGE, data: ["releaseHash": receivedReleaseHash, "progress": progress]
+                  )
+                },
+                resolve: {resOp in
+                  StallionUtil.setLs(key: StallionConstants.CURRENT_STAGE_SLOT_KEY, value: "/" + StallionConstants.TEMP_FOLDER_SLOT)
+                  StallionUtil.setLs(key: "/" + StallionConstants.STAGE_DIRECTORY + "/" + StallionConstants.TEMP_FOLDER_SLOT, value: receivedReleaseHash)
+                  StallionEventEmitter.sendEvent(eventType: StallionConstants.NativeEventTypesStage.DOWNLOAD_COMPLETE_STAGE, data: stageDownloadEventBody
+                  )
+                  resolve(resOp)
+                },
+                reject: {code, message, error in
+                  StallionEventEmitter.sendEvent(eventType: StallionConstants.NativeEventTypesStage.DOWNLOAD_ERROR_STAGE, data: stageDownloadEventBody
+                  )
+                  reject(code, message, error)
+                }
+            )
         } catch {
             let errorString = StallionConstants.DownloadPromiseResponses.GenericError
+            StallionEventEmitter.sendEvent(eventType: StallionConstants.NativeEventTypesStage.DOWNLOAD_ERROR_STAGE, data: stageDownloadEventBody
+            )
             reject("500", errorString, NSError(domain: errorString, code: 500))
         }
     }
-    
-    @objc(setApiKey:)
-    func setApiKey(apiKey: String) {
-        StallionUtil.setLs(key: StallionUtil.LSKeys.apiKey, value: apiKey)
+  
+    @objc
+    func getStorage(_ storageKey: String, callback: RCTResponseSenderBlock) {
+        let value = StallionUtil.getLs(key: storageKey)
+        callback([value])
     }
     
-    @objc(getApiKey:)
-    func getApiKey(_ callback: RCTResponseSenderBlock) {
-        let apiKey = StallionUtil.getLs(key: StallionUtil.LSKeys.apiKey)
-        callback([apiKey ?? ""])
+    @objc
+    func setStorage(_ storageKey: String, value: String) {
+      StallionUtil.setLs(key: storageKey, value: value)
     }
     
-    @objc(toggleStallionSwitch:)
-    func toggleStallionSwitch(isOn: Bool) {
-        StallionUtil.setLs(key: StallionUtil.LSKeys.switchStateKey, value: isOn ? StallionUtil.SwitchStates.ON : StallionUtil.SwitchStates.OFF)
+    @objc
+    func onLaunch(_ launchData: String) {
+      StallionObjUtil.isMounted = true
+      emitPendingEvents()
+    }
+  
+    @objc
+    func sync() {
+      StallionSyncManager.sync()
+    }
+  
+    @objc
+    func getUniqueId(_ callback: RCTResponseSenderBlock) {
+      callback([StallionSyncManager.getUniqueId()])
+    }
+  
+    @objc
+    func getProjectId(_ callback: RCTResponseSenderBlock) {
+      let projectId = Bundle.main.infoDictionary?[StallionConstants.STALLION_PROJECT_ID_IDENTIFIER] as? String ?? ""
+      callback([projectId])
     }
     
-    @objc(getStallionMeta:)
-    func getStallionMeta(_ callback: RCTResponseSenderBlock) {
-        var metaDictionary = [String:Any]()
-        metaDictionary[StallionUtil.LSKeys.bucketKey] = StallionUtil.getLs(key: StallionUtil.LSKeys.bucketKey)
-        metaDictionary[StallionUtil.LSKeys.versionKey] = StallionUtil.getLs(key: StallionUtil.LSKeys.versionKey)
-        metaDictionary[StallionUtil.LSKeys.switchStateKey] = StallionUtil.getLs(key: StallionUtil.LSKeys.switchStateKey) == StallionUtil.SwitchStates.ON
-        let stallionMeta = NSDictionary(dictionary: metaDictionary)
-        callback([stallionMeta])
+    @objc
+    func getAppToken(_ callback: RCTResponseSenderBlock) {
+      let appToken = Bundle.main.infoDictionary?[StallionConstants.STALLION_APP_TOKEN_IDENTIFIER] as? String ?? ""
+      callback([appToken])
+    }
+  
+    func emitPendingEvents() {
+      let flushedEvents = StallionEventManager.sharedInstance().flushAllEvents() as NSArray
+      for event in flushedEvents {
+          if var eventDict = event as? [String: Any] {
+            var payload = eventDict["payload"] as? Dictionary<String, Any> ?? [:]
+            payload[StallionConstants.APP_VERION_EVENT_KEY] = StallionSyncManager.getAppVersion()
+            eventDict["payload"] = payload
+            Stallion.shared?.sendEvent(withName: StallionConstants.STALLION_NATIVE_EVENT_NAME, body: eventDict)
+          }
+      }
     }
 }

package/ios/main/StallionConstants.swift

@@ -14,19 +14,11 @@ class StallionConstants {
         static let ZipFolderName = "build"
         static let ZipExtension = "zip"
     }
-    public struct HeaderKeys {
-        static let AccessKey = "x-sdk-access-token"
-        static let ContentType = "Content-Type"
-    }
     public struct DownloadReqBodyKeys {
         static let DownloadUrl = "url"
-        static let BucketId = "bucketId"
-        static let Version = "version"
-        static let Platform = "platform"
-        static let ProjectId = "projectId"
+        static let Hash = "hash"
     }
     static let PlatformValue = "ios"
-    static let DownloadApiUrl = "https://stallion-api.redhorse.tech/api/v1/bundle/download"
     public struct DownloadPromiseResponses {
         static let Success = "Success"
         static let GenericError = "Something went wrong internally"
@@ -34,11 +26,61 @@ class StallionConstants {
         static let ApiError = "Download api error"
         static let InitError = "Download initialisation error"
         static let DirectoryInitError = "Directory initialisation error"
+        static let SyncApiError = "Sync api error"
     }
     public struct AuthTokens {
         static let ApiKey = "apiKey"
         static let SecretKey = "secretKey"
     }
-    static let DOWNLOAD_PROGRESS_EVENT = "StallionDownloadProgress";
     static let PROGRESS_EVENT_THRESHOLD: Float = 0.05;
+  
+    static let PROD_DIRECTORY = "StallionProd"
+    static let STAGE_DIRECTORY = "StallionStage"
+    static let TEMP_FOLDER_SLOT = "temp"
+    static let NEW_FOLDER_SLOT = "StallionNew"
+    static let STABLE_FOLDER_SLOT = "StallionStable"
+    static let DEFAULT_FOLDER_SLOT = "Default"
+
+    static let CURRENT_PROD_SLOT_KEY = "stallionProdCurrentSlot"
+    static let CURRENT_STAGE_SLOT_KEY = "stallionStageCurrentSlot"
+    static let STALLION_API_BASE = "https://api.stalliontech.io"
+    static let STALLION_INFO_API_PATH = "/api/v1/promoted/get-update-meta"
+    static let STALLION_PROJECT_ID_IDENTIFIER = "StallionProjectId"
+    static let STALLION_APP_TOKEN_IDENTIFIER = "StallionAppToken"
+    static let APP_VERION_IDENTIFIER = "CFBundleShortVersionString"
+    static let STALLION_APP_TOKEN_KEY = "x-app-token"
+    static let STALLION_SDK_TOKEN_KEY = "x-sdk-access-token"
+    static let STALLION_UID_KEY = "uid"
+    static let UNIQUE_ID_IDENTIFIER = "stallionDeviceId"
+
+    static let NEW_RELEASE_HASH_ID = "stallionNewReleaseHash"
+    static let NEW_RELEASE_URL_ID = "stallionNewReleaseUrl"
+  
+    static let STALLION_SWITCH_STATE_IDENTIFIER = "switchState";
+    static let LAST_ROLLED_BACK_RELEASE_HASH_KEY = "LAST_ROLLED_BACK_RELEASE_HASH";
+  
+    static let APP_VERION_EVENT_KEY = "AppVersion"
+
+    public struct SwitchState {
+      static let PROD = "PROD"
+      static let STAGE = "STAGE"
+    }
+  
+    static let STALLION_NATIVE_EVENT_NAME = "STALLION_NATIVE_EVENT"
+    public struct NativeEventTypesProd {
+      static let DOWNLOAD_STARTED_PROD = "DOWNLOAD_STARTED_PROD"
+      static let DOWNLOAD_ERROR_PROD = "DOWNLOAD_ERROR_PROD"
+      static let DOWNLOAD_PROGRESS_PROD = "DOWNLOAD_PROGRESS_PROD"
+      static let DOWNLOAD_COMPLETE_PROD = "DOWNLOAD_COMPLETE_PROD"
+      static let SYNC_ERROR_PROD = "SYNC_ERROR_PROD"
+      static let ROLLED_BACK_PROD = "ROLLED_BACK_PROD"
+      static let INSTALLED_PROD = "INSTALLED_PROD"
+      static let STABILIZED_PROD = "STABILIZED_PROD"
+      static let EXCEPTION_PROD = "EXCEPTION_PROD"
+    }
+    public struct NativeEventTypesStage {
+      static let DOWNLOAD_ERROR_STAGE = "DOWNLOAD_ERROR_STAGE"
+      static let DOWNLOAD_PROGRESS_STAGE = "DOWNLOAD_PROGRESS_STAGE"
+      static let DOWNLOAD_COMPLETE_STAGE = "DOWNLOAD_COMPLETE_STAGE"
+    }
 }

package/ios/main/StallionDownloader.swift

@@ -7,40 +7,42 @@
 import Foundation
 import ZIPFoundation
 
-enum StallionError: Error {
-    case runtimeError(String)
-}
-
 class StallionDownloader: NSObject {
     
-    private lazy var urlSession = URLSession(configuration: .default,
+  private lazy var urlSession = URLSession(configuration: .default,
                                                  delegate: self,
                                                  delegateQueue: nil)
+  var downloadTask : URLSessionDownloadTask?;
+  var _downloadPaths: [String] = [];
     
-    var downloadTask : URLSessionDownloadTask?;
-    var reqJson: [String: Any]?;
+  var _resolve: RCTPromiseResolveBlock?;
+  var _reject: RCTPromiseRejectBlock?;
+  var _onProgress: ((Float) -> Void)?
+  var lastSentProgress: Float = 0;
     
-    var _resolve: RCTPromiseResolveBlock?;
-    var _reject: RCTPromiseRejectBlock?;
-    var lastSentProgress: Float = 0;
-    
-    override init() {
-        super.init()
-    }
+  override init() {
+      super.init()
+  }
 
-    func load(url: URL, reqBody: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) throws {
-            self.reqJson = reqBody
-            self._resolve = resolve
-            self._reject = reject
-            
-            var request = URLRequest(url: url)
-            request.httpMethod = "GET"
+  func load(url: URL, downloadPaths: [String], onProgress: @escaping ((Float) -> Void), resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) throws {
+        self._resolve = resolve
+        self._reject = reject
+        self._downloadPaths = downloadPaths
+        self._onProgress = onProgress
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
 
-            request.setValue(StallionUtil.getLs(key: StallionUtil.LSKeys.apiKey) ?? "", forHTTPHeaderField: StallionConstants.HeaderKeys.AccessKey)
-            let task = urlSession.downloadTask(with: request)
-            task.resume()
-            self.downloadTask = task
-    }
+        let sdkToken = StallionSyncManager.getSdkToken()
+
+        request.setValue(StallionSyncManager.getAppToken(), forHTTPHeaderField: StallionConstants.STALLION_APP_TOKEN_KEY)
+        if(!sdkToken.isEmpty) {
+            request.setValue(sdkToken, forHTTPHeaderField: StallionConstants.STALLION_SDK_TOKEN_KEY)
+        }
+        let task = urlSession.downloadTask(with: request)
+        task.resume()
+        self.downloadTask = task
+      }
 }
 
 extension StallionDownloader: URLSessionDownloadDelegate {
@@ -54,9 +56,7 @@ extension StallionDownloader: URLSessionDownloadDelegate {
             let calculatedProgress = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
             if((calculatedProgress - self.lastSentProgress) > StallionConstants.PROGRESS_EVENT_THRESHOLD) {
                 self.lastSentProgress = calculatedProgress
-                DispatchQueue.main.async {
-                    Stallion.shared?.sendEvent(withName: StallionConstants.DOWNLOAD_PROGRESS_EVENT, body: calculatedProgress)
-                }
+                self._onProgress?(calculatedProgress)
             }
         }
     }
@@ -71,19 +71,18 @@ extension StallionDownloader: URLSessionDownloadDelegate {
         let response = downloadTask.response as? HTTPURLResponse
         if (response?.statusCode == 200) {
             do  {
-                let tempDownloadDirectory = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
-                    .appendingPathComponent(StallionConstants.FilePaths.DownloadDirectory, isDirectory: true)
-                
-                if !FileManager.default.fileExists(atPath: tempDownloadDirectory.path) {
-                    try FileManager.default.createDirectory(atPath: tempDownloadDirectory.path, withIntermediateDirectories: true, attributes: nil)
+              let documentFolderPath = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
+              let finalDestinationDirectory = self._downloadPaths.reduce(documentFolderPath, { url, pathComponent in
+                url.appendingPathComponent(String(pathComponent), isDirectory: true)
+              })
+              
+                if !FileManager.default.fileExists(atPath: finalDestinationDirectory.path) {
+                    try FileManager.default.createDirectory(atPath: finalDestinationDirectory.path, withIntermediateDirectories: true, attributes: nil)
                 }
                 
-                let finalDestinationDirectory = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
-                    .appendingPathComponent(StallionConstants.FilePaths.TargetDirectory, isDirectory: true)
-                
-                let downloadedBuildDirectory = tempDownloadDirectory.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName, isDirectory: true)
+              let downloadedBuildDirectory = finalDestinationDirectory.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName, isDirectory: true)
                 
-                let downloadedZipFilePath = tempDownloadDirectory.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName, isDirectory: false).appendingPathExtension(StallionConstants.FilePaths.ZipExtension)
+                let downloadedZipFilePath = finalDestinationDirectory.appendingPathComponent(StallionConstants.FilePaths.ZipFolderName, isDirectory: false).appendingPathExtension(StallionConstants.FilePaths.ZipExtension)
             
                 let fileManager = FileManager()
                 
@@ -97,20 +96,8 @@ extension StallionDownloader: URLSessionDownloadDelegate {
                 if FileManager.default.fileExists(atPath: downloadedBuildDirectory.path) {
                     try fileManager.removeItem(at: downloadedBuildDirectory)
                 }
-                try fileManager.unzipItem(at: downloadedZipFilePath, to: tempDownloadDirectory, skipCRC32: false, progress: nil, preferredEncoding: nil)
+              try fileManager.unzipItem(at: downloadedZipFilePath, to: finalDestinationDirectory, skipCRC32: false, progress: nil, pathEncoding: nil)
                 try fileManager.removeItem(at: downloadedZipFilePath)
-                
-                // if build exists in final destination, ovverride it
-                if FileManager.default.fileExists(atPath: finalDestinationDirectory.path) {
-                    try fileManager.removeItem(at: finalDestinationDirectory)
-                }
-                try fileManager.moveItem(at: tempDownloadDirectory, to: finalDestinationDirectory)
-                let bucketId =  self.reqJson?[StallionConstants.DownloadReqBodyKeys.BucketId] as? String ?? ""
-                let receivedVersion =  self.reqJson?[StallionConstants.DownloadReqBodyKeys.Version] as? Int ?? -1
-                StallionUtil.setLs(key: StallionUtil.LSKeys.bucketKey, value: bucketId)
-                if receivedVersion > -1 {
-                    StallionUtil.setLs(key: StallionUtil.LSKeys.versionKey, value: String(receivedVersion))
-                }
                 self._resolve?(StallionConstants.DownloadPromiseResponses.Success)
             } catch {
                 // throw exception here

package/ios/main/StallionErrorBoundary.h

@@ -2,7 +2,7 @@
 //  StallionErrorBoundary.h
 //  react-native-stallion
 //
-//  Created by Jasbir Singh on 24/12/23.
+//  Created by Thor963 on 24/12/23.
 //
 
 #import <Foundation/Foundation.h>

package/ios/main/StallionErrorBoundary.m

@@ -2,10 +2,14 @@
 //  StallionErrorBoundary.m
 //  react-native-stallion
 //
-//  Created by Jasbir Singh on 24/12/23.
+//  Created by Thor963 on 24/12/23.
 //
 
 #import "StallionErrorBoundary.h"
+#import "StallionEventManager.h"
+#import "StallionObjConstants.h"
+#import "StallionObjUtil.h"
+#import "StallionRollbackHandler.h"
 
 @implementation StallionErrorBoundary
     
@@ -29,34 +33,47 @@ BOOL exceptionAlertDismissed = FALSE;
 void handleException(NSException *exception)
 {
     NSString *switchState = [[NSUserDefaults standardUserDefaults]
-        stringForKey:@"switchState"];
-    if([switchState isEqual:@"STALLION_ON"]) {
-        [[NSUserDefaults standardUserDefaults] setObject:@"DEFAULT" forKey:@"switchState"];
-        [[NSUserDefaults standardUserDefaults] synchronize];
-        NSString * readeableError = [exception reason];
-        UIAlertController* alert = [UIAlertController
-                                    alertControllerWithTitle:@"Stallion Error Boundary"
-                                    message:[NSString stringWithFormat:@"%@\n%@",
-                                             @"A crash occurred in the app. We have switched Stallion off. Check crash report below. Continue crash to invoke other exception handlers. \n \n",
-                                             readeableError]
-                                    preferredStyle:UIAlertControllerStyleAlert];
-        
-        [alert addAction:[UIAlertAction actionWithTitle:@"Continue Crash"
-                                                  style:UIAlertActionStyleDefault
-                                                handler:^(UIAlertAction *action) {
-                                                    exceptionAlertDismissed = TRUE;
-                                                }]];
-        
-        UIApplication* app = [UIApplication sharedApplication];
-        UIViewController * rootViewController = app.delegate.window.rootViewController;
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [rootViewController presentViewController:alert animated:YES completion:nil];
-        });
-        while (exceptionAlertDismissed == FALSE)
-        {
-            [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
-        }
+                             stringForKey:[StallionObjConstants switch_state_identifier]];
+    NSString * readeableError = [exception reason];
+    if([switchState isEqual:[StallionObjConstants switch_state_prod]]) {
+      NSString *currentProdSlot = [[NSUserDefaults standardUserDefaults] stringForKey:StallionObjConstants.current_prod_slot_key] ?: @"";
+      NSString *currentHashPath = [NSString stringWithFormat:@"/%@%@", [StallionObjConstants prod_directory], currentProdSlot];
+      NSString *currentHash = [[NSUserDefaults standardUserDefaults] stringForKey:currentHashPath] ?: @"";
+      BOOL isAutoRollback = ![StallionObjUtil isMounted];
+      if(![currentProdSlot isEqual:StallionObjConstants.default_folder_slot]) {
+        [[StallionEventManager sharedInstance] queueRNEvent:[StallionObjConstants exception_prod_event] withData:@{@"error" : readeableError, StallionObjConstants.release_hash_key: currentHash, StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false" }];
+      }
+      if(isAutoRollback) {
+        [StallionRollbackHandler rollbackProd:true];
+      }
+    }  else if([switchState isEqual:[StallionObjConstants switch_state_stage]]) {
+      [StallionRollbackHandler rollbackStage];
+      UIAlertController* alert = [UIAlertController
+                                  alertControllerWithTitle:@"Stallion Error Boundary"
+                                  message:[NSString stringWithFormat:@"%@\n%@",
+                                           @"A crash occurred in the app. Build was rolled back. Check crash report below. Continue crash to invoke other exception handlers. \n \n",
+                                           readeableError]
+                                  preferredStyle:UIAlertControllerStyleAlert];
+      
+      [alert addAction:[UIAlertAction actionWithTitle:@"Continue Crash"
+                                                style:UIAlertActionStyleDefault
+                                              handler:^(UIAlertAction *action) {
+                                                  exceptionAlertDismissed = TRUE;
+                                              }]];
+      
+      UIApplication* app = [UIApplication sharedApplication];
+      UIViewController * rootViewController = app.delegate.window.rootViewController;
+      dispatch_async(dispatch_get_main_queue(), ^{
+          [rootViewController presentViewController:alert animated:YES completion:nil];
+      });
+      while (exceptionAlertDismissed == FALSE)
+      {
+          [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+      }
     }
+  if(_defaultExceptionHandler) {
+    _defaultExceptionHandler(exception);
+  }
 }
 
 @end