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

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

@@ -1,6 +1,13 @@
 package com.stallion;
 
 import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import java.io.File;
 
 public class Stallion {
 
@@ -8,19 +15,96 @@ public class Stallion {
     return getJSBundleFile(applicationContext, null);
   }
 
+  private static String getDefaultBundle(String defaultBundlePath) {
+    if(defaultBundlePath != null && !defaultBundlePath.isEmpty()) {
+      return defaultBundlePath;
+    } else {
+      return StallionConstants.DEFAULT_JS_BUNDLE_LOCATION_BASE + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+    }
+  }
+
+  private static String getAppVersion() throws PackageManager.NameNotFoundException {
+    Context appContext = StallionStorage.getInstance().mContext;
+    String parentPackageName= appContext.getPackageName();
+    PackageInfo pInfo = appContext.getPackageManager().getPackageInfo(parentPackageName, 0);
+    return pInfo.versionName;
+  }
+
+  private static void sendInstallEvent(String installedReleaseHash) {
+    WritableMap successEventPayload = Arguments.createMap();
+    successEventPayload.putString("releaseHash", installedReleaseHash);
+    StallionEventEmitter.sendEvent(
+      StallionEventEmitter.getEventPayload(
+        StallionConstants.NativeEventTypesProd.INSTALLED_PROD.toString(),
+        successEventPayload
+      )
+    );
+  }
+
   public static String getJSBundleFile(Context applicationContext, String defaultBundlePath) {
     StallionStorage.getInstance().Initialize(applicationContext);
     StallionStorage stallionStorageInstance = StallionStorage.getInstance();
-    if (
-      stallionStorageInstance.get(StallionConstants.ACTIVE_BUCKET_IDENTIFIER) != null &&
-        stallionStorageInstance.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER) != null &&
-        stallionStorageInstance.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER).equals(StallionConstants.STALLION_SWITCH_ON)
-    ) {
-      int currentActiveSlot = stallionStorageInstance.getInt(StallionConstants.ACTIVE_SLOT_IDENTIFIER);
-      return applicationContext.getFilesDir().getAbsolutePath() + StallionConstants.STALLION_PACKAGE_PATH + StallionConstants.BUNDLE_DEST_FOLDER_DIR + StallionConstants.SLOT_FOLDER_DIR + currentActiveSlot + "/" + StallionConstants.UNZIP_FOLDER_NAME + "/" + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
-    } else {
-      if (defaultBundlePath != null) return defaultBundlePath;
-      return StallionConstants.DEFAULT_JS_BUNDLE_LOCATION_BASE + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+    String baseFolderPath = applicationContext.getFilesDir().getAbsolutePath();
+    String switchState = stallionStorageInstance.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
+    String currentAppVersion = "";
+    try {
+      String stallionAppVersionCache = stallionStorageInstance.get(StallionConstants.STALLION_APP_VERSION_IDENTIFIER);
+        currentAppVersion = getAppVersion();
+        if(!stallionAppVersionCache.equals(currentAppVersion)) {
+          stallionStorageInstance.set(StallionConstants.STALLION_APP_VERSION_IDENTIFIER, currentAppVersion);
+          StallionRollbackManager.fallbackProd();
+        }
+    } catch (PackageManager.NameNotFoundException e) {}
+
+    if(switchState.isEmpty()) {
+      stallionStorageInstance.set(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER, StallionConstants.SwitchState.PROD.toString());
+      switchState = StallionConstants.SwitchState.PROD.toString();
+    }
+    if(switchState.equals(StallionConstants.SwitchState.PROD.toString())) {
+      String currentProdSlot = stallionStorageInstance.get(StallionConstants.CURRENT_PROD_SLOT_KEY);
+      switch (currentProdSlot) {
+        case StallionConstants.TEMP_FOLDER_SLOT:
+          String newReleaseHash = stallionStorageInstance.get(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT);
+          if(!newReleaseHash.isEmpty()) {
+            StallionRollbackManager.stabilizeRelease();
+          }
+          StallionFileUtil.moveFile(
+            new File(baseFolderPath, StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT),
+            new File(baseFolderPath, StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT)
+          );
+          String tempReleaseHash = stallionStorageInstance.get(StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT);
+          stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, tempReleaseHash);
+          stallionStorageInstance.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.NEW_FOLDER_SLOT);
+          stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, "");
+          sendInstallEvent(tempReleaseHash);
+          return baseFolderPath + StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT + StallionConstants.UNZIP_FOLDER_NAME + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+        case StallionConstants.NEW_FOLDER_SLOT:
+          return baseFolderPath + StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT + StallionConstants.UNZIP_FOLDER_NAME + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+        case StallionConstants.STABLE_FOLDER_SLOT:
+          return baseFolderPath + StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT + StallionConstants.UNZIP_FOLDER_NAME + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+        default:
+          return getDefaultBundle(defaultBundlePath);
+      }
+    }
+    if(switchState.equals(StallionConstants.SwitchState.STAGE.toString())) {
+      String currentStageSlot = stallionStorageInstance.get(StallionConstants.CURRENT_STAGE_SLOT_KEY);
+      switch (currentStageSlot) {
+        case StallionConstants.TEMP_FOLDER_SLOT:
+          StallionFileUtil.moveFile(
+            new File(baseFolderPath, StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT),
+            new File(baseFolderPath, StallionConstants.STAGE_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT)
+          );
+          String tempReleaseHash = stallionStorageInstance.get(StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT);
+          stallionStorageInstance.set(StallionConstants.STAGE_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, tempReleaseHash);
+          stallionStorageInstance.set(StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, "");
+          stallionStorageInstance.set(StallionConstants.CURRENT_STAGE_SLOT_KEY, StallionConstants.NEW_FOLDER_SLOT);
+          return baseFolderPath + StallionConstants.STAGE_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT + StallionConstants.UNZIP_FOLDER_NAME + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+        case StallionConstants.NEW_FOLDER_SLOT:
+          return baseFolderPath + StallionConstants.STAGE_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT + StallionConstants.UNZIP_FOLDER_NAME + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+        default:
+          return getDefaultBundle(defaultBundlePath);
+      }
     }
+    return getDefaultBundle(defaultBundlePath);
   }
 }

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

@@ -0,0 +1,58 @@
+package com.stallion;
+
+import org.json.JSONObject;
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class StallionApiUtil {
+  public static JSONObject post(String urlString, String requestBodyString, String token, String sdkToken) {
+    StringBuilder result = new StringBuilder();
+    HttpURLConnection urlConnection = null;
+    try {
+      URL url = new URL(urlString);
+      urlConnection = (HttpURLConnection) url.openConnection();
+      urlConnection.setRequestMethod("POST");
+      urlConnection.setRequestProperty("Content-Type", "application/json");
+      urlConnection.setRequestProperty(StallionConstants.STALLION_APP_TOKEN_KEY, token);
+      if(!sdkToken.isEmpty()) {
+        urlConnection.setRequestProperty(StallionConstants.STALLION_SDK_TOKEN_KEY, sdkToken);
+      }
+      urlConnection.setRequestProperty(StallionConstants.STALLION_DEVICE_ID_KEY, StallionCommonUtil.getUniqueId());
+
+      urlConnection.setDoOutput(true);
+
+      OutputStream os = urlConnection.getOutputStream();
+      OutputStreamWriter osw = new OutputStreamWriter(os, "UTF-8");
+      osw.write(requestBodyString);
+      osw.flush();
+      osw.close();
+      os.close();
+
+      urlConnection.connect();
+
+      InputStream in = new BufferedInputStream(urlConnection.getInputStream());
+      BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+      String line;
+      while ((line = reader.readLine()) != null) {
+        result.append(line);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    } finally {
+      if (urlConnection != null) {
+        urlConnection.disconnect();
+      }
+    }
+    try {
+      return new JSONObject(result.toString());
+    } catch (Exception e) {
+      return new JSONObject();
+    }
+  }
+}

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

@@ -0,0 +1,25 @@
+package com.stallion;
+
+import android.content.Context;
+import android.provider.Settings;
+
+import java.util.UUID;
+
+public class StallionCommonUtil {
+  public static String getUniqueId() {
+    StallionStorage stallionStorage = StallionStorage.getInstance();
+    String cachedUniqueId = stallionStorage.get(StallionConstants.UNIQUE_ID_IDENTIFIER);
+    if(!cachedUniqueId.isEmpty()) {
+      return  cachedUniqueId;
+    }
+    String uniqueId;
+    try {
+      Context currContext = StallionStorage.getInstance().mContext;
+      uniqueId = Settings.Secure.getString(currContext.getContentResolver(), Settings.Secure.ANDROID_ID);
+    } catch (Exception e) {
+      uniqueId = UUID.randomUUID().toString();
+    }
+    stallionStorage.set(StallionConstants.UNIQUE_ID_IDENTIFIER, uniqueId);
+    return  uniqueId;
+  }
+}

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

@@ -2,26 +2,17 @@ package com.stallion;
 
 public class StallionConstants {
   public static final String MODULE_NAME = "Stallion";
-  public static final String STALLION_PACKAGE_PATH = "/StallionPackage";
   public static final int DOWNLOAD_BUFFER_SIZE = 1024 * 256;
 
   public static final String DOWNLOAD_ERROR_PREFIX = "Stallion download error: ";
-  public static final String DOWNLOAD_FOLDER_DIR = "/downloads";
-  public static final String BUNDLE_DEST_FOLDER_DIR = "/stallion-build";
-  public static final String SLOT_FOLDER_DIR = "/slots/";
+
   public static final String ZIP_FILE_NAME = "build.zip";
-  public static final String UNZIP_FOLDER_NAME = "build";
-  public static final String ANDROID_BUNDLE_FILE_NAME = "index.android.bundle";
-  public static final String DEFAULT_JS_BUNDLE_LOCATION_BASE = "assets://";
-  public static final String DOWNLOAD_PROGRESS_EVENT = "StallionDownloadProgress";
-
-  public static final String ACTIVE_BUCKET_IDENTIFIER = "activeBucket";
-  public static final String ACTIVE_VERSION_IDENTIFIER = "activeVersion";
-  public static final String ACTIVE_SLOT_IDENTIFIER = "activeSlot";
+  public static final String UNZIP_FOLDER_NAME = "/build";
+  public static final String ANDROID_BUNDLE_FILE_NAME = "/index.android.bundle";
+  public static final String DEFAULT_JS_BUNDLE_LOCATION_BASE = "assets:/";
+
   public static final String STALLION_SWITCH_STATE_IDENTIFIER = "switchState";
-  public static final String API_KEY_IDENTIFIER = "apiKey";
-  public static final String STALLION_SWITCH_ON = "STALLION_ON";
-  public static final String STALLION_SWITCH_OFF = "DEFAULT";
+  public static final String STALLION_APP_VERSION_IDENTIFIER = "stallionAppVersion";
 
   public static final String DOWNLOAD_SUCCESS_MESSAGE = "Success";
 
@@ -33,5 +24,50 @@ public class StallionConstants {
 
   public static final String DOWNLOAD_DELETE_ERROR = "Download operation cleanup error";
 
+
+  public static final String PROD_DIRECTORY = "/StallionProd";
+  public static final String STAGE_DIRECTORY = "/StallionStage";
+  public static final String TEMP_FOLDER_SLOT = "/temp";
+  public static final String NEW_FOLDER_SLOT = "/StallionNew";
+  public static final String STABLE_FOLDER_SLOT = "/StallionStable";
+  public static final String DEFAULT_FOLDER_SLOT = "/Default";
+
+  public static final String CURRENT_PROD_SLOT_KEY = "stallionProdCurrentSlot";
+  public static final String CURRENT_STAGE_SLOT_KEY = "stallionStageCurrentSlot";
+  public static final String STALLION_API_BASE = "https://api.stalliontech.io";
+  public static final String STALLION_INFO_API_PATH = "/api/v1/promoted/get-update-meta";
+  public static final String STALLION_PROJECT_ID_IDENTIFIER = "StallionProjectId";
+  public static final String STALLION_APP_TOKEN_IDENTIFIER = "StallionAppToken";
+  public static final String STALLION_APP_TOKEN_KEY = "x-app-token";
+  public static final String STALLION_SDK_TOKEN_KEY = "x-sdk-access-token";
+  public static final String STALLION_DEVICE_ID_KEY = "uid";
+  public static final String LAST_ROLLED_BACK_RELEASE_HASH_KEY = "LAST_ROLLED_BACK_RELEASE_HASH";
+
+  public static final String NEW_RELEASE_HASH_ID = "stallionNewReleaseHash";
+  public static final String NEW_RELEASE_URL_ID = "stallionNewReleaseUrl";
+  public static final String UNIQUE_ID_IDENTIFIER = "stallionDeviceId";
+
+  public static enum SwitchState {
+    PROD,
+    STAGE
+  }
+  public  static final String STALLION_NATIVE_EVENT_NAME = "STALLION_NATIVE_EVENT";
+  public enum NativeEventTypesProd {
+    DOWNLOAD_STARTED_PROD,
+    DOWNLOAD_ERROR_PROD,
+    DOWNLOAD_PROGRESS_PROD,
+    DOWNLOAD_COMPLETE_PROD,
+    SYNC_ERROR_PROD,
+    ROLLED_BACK_PROD,
+    INSTALLED_PROD,
+    STABILIZED_PROD,
+    EXCEPTION_PROD,
+    AUTO_ROLLED_BACK_PROD
+  }
+  public  enum NativeEventTypesStage {
+    DOWNLOAD_ERROR_STAGE,
+    DOWNLOAD_PROGRESS_STAGE,
+    DOWNLOAD_COMPLETE_STAGE,
+  }
 }
 

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

@@ -0,0 +1,7 @@
+package com.stallion;
+
+public interface StallionDownloadCallback {
+  void onReject(String prefix, String error);
+  void onSuccess(String successPayload);
+  void onProgress(double downloadFraction);
+}

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

@@ -0,0 +1,121 @@
+package com.stallion;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class StallionDownloadManager {
+  public static void downloadBundle(
+    String downloadUrl,
+    String downloadDirectory,
+    String sdkAccessToken,
+    String appAccessToken,
+    StallionDownloadCallback stallionDownloadCallback
+  ) {
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+
+    executor.execute(() -> {
+
+      FileOutputStream fout = null;
+      BufferedOutputStream bout = null;
+      BufferedInputStream inputStream = null;
+      HttpURLConnection connection = null;
+      File downloadedZip = null;
+      boolean isZip = false;
+
+      try {
+        int DOWNLOAD_BUFFER_SIZE = StallionConstants.DOWNLOAD_BUFFER_SIZE;
+        URL url = new URL(downloadUrl);
+        connection = (HttpURLConnection) url.openConnection();
+        connection.setRequestMethod( "GET" );
+        if(!sdkAccessToken.isEmpty()) {
+          connection.setRequestProperty("x-sdk-access-token", sdkAccessToken);
+        }
+        if(!appAccessToken.isEmpty()) {
+          connection.setRequestProperty("x-app-token", appAccessToken);
+        }
+
+        connection.setDoInput(true);
+
+        connection.connect();
+        inputStream = new BufferedInputStream(connection.getInputStream());
+        File downloadFolder = new File(downloadDirectory);
+        if(downloadFolder.exists()) {
+          StallionFileUtil.deleteFileOrFolderSilently(downloadFolder);
+        }
+        downloadFolder.getParentFile().mkdirs();
+
+        downloadedZip = new File(downloadFolder, StallionConstants.ZIP_FILE_NAME);
+        downloadedZip.getParentFile().mkdirs();
+
+        fout = new FileOutputStream(downloadedZip, false);
+        bout = new BufferedOutputStream(fout, DOWNLOAD_BUFFER_SIZE);
+        byte[] data = new byte[DOWNLOAD_BUFFER_SIZE];
+        byte[] header = new byte[4];
+
+        long totalBytes = connection.getContentLength();
+        long receivedBytes = 0;
+        int numBytesRead;
+        double prevDownloadFraction = 0;
+        double progressEventThreshold = 0.1;
+        while ((numBytesRead = inputStream.read(data, 0, DOWNLOAD_BUFFER_SIZE)) >= 0) {
+          if (receivedBytes < 4) {
+            for (int i = 0; i < numBytesRead; i++) {
+              int headerOffset = (int) (receivedBytes) + i;
+              if (headerOffset >= 4) {
+                break;
+              }
+              header[headerOffset] = data[i];
+            }
+          }
+
+          receivedBytes += numBytesRead;
+          bout.write(data, 0, numBytesRead);
+          double currentDownloadFraction = (double) receivedBytes / (double) totalBytes;
+          if(currentDownloadFraction - prevDownloadFraction > progressEventThreshold) {
+            prevDownloadFraction = currentDownloadFraction;
+            stallionDownloadCallback.onProgress(currentDownloadFraction);
+          }
+        }
+
+        isZip = ByteBuffer.wrap(header).getInt() == 0x504b0304;
+      } catch (Exception e) {
+        stallionDownloadCallback.onReject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_API_ERROR_MESSAGE);
+      } finally {
+        try {
+          if (bout != null) bout.close();
+          if (fout != null) fout.close();
+          if (inputStream != null) inputStream.close();
+          if (connection != null) connection.disconnect();
+        } catch (IOException e) {
+          stallionDownloadCallback.onReject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_API_ERROR_MESSAGE);
+        }
+      }
+
+      if (!isZip) {
+        stallionDownloadCallback.onReject(StallionConstants.DOWNLOAD_ERROR_PREFIX, "Not a zip file");
+        return;
+      }
+
+      try {
+        StallionFileUtil.unzipFile(downloadedZip.getAbsolutePath(), downloadDirectory);
+        stallionDownloadCallback.onSuccess(StallionConstants.DOWNLOAD_SUCCESS_MESSAGE);
+      } catch (Exception e) {
+        stallionDownloadCallback.onReject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_FILESYSTEM_ERROR_MESSAGE);
+      } finally {
+        try {
+          StallionFileUtil.deleteFileOrFolderSilently(downloadedZip);
+        } catch (Exception e) {
+          stallionDownloadCallback.onReject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_DELETE_ERROR);
+        }
+      }
+    });
+  }
+}

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

@@ -1,22 +1,24 @@
 package com.stallion;
 
 import android.app.Activity;
-import android.content.Context;
 import android.content.Intent;
 import android.util.Log;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
 
 public class StallionErrorBoundary {
   public static Thread.UncaughtExceptionHandler _androidUncaughtExceptionHandler;
   public static Thread _exceptionThread;
   public static Throwable _exceptionThrowable;
-
   public static ReactApplicationContext _currentContext;
+
   public static void initErrorBoundary(ReactApplicationContext currentContext) {
     _androidUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
     _currentContext = currentContext;
   }
+
   public static void toggleExceptionHandler(Boolean shouldEnableErrorHandler) {
     if(shouldEnableErrorHandler) {
       Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
@@ -24,8 +26,30 @@ public class StallionErrorBoundary {
         _exceptionThrowable = throwable;
         String stackTraceString = Log.getStackTraceString(throwable);
         StallionStorage stallionStorage = StallionStorage.getInstance();
-        if(stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER).equals(StallionConstants.STALLION_SWITCH_ON)) {
-          stallionStorage.set(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER, StallionConstants.STALLION_SWITCH_OFF);
+        String switchState = stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
+
+        if(switchState.equals(StallionConstants.SwitchState.PROD.toString())) {
+          String currentProdSlot = stallionStorage.get(StallionConstants.CURRENT_PROD_SLOT_KEY);
+          boolean isAutoRollback = !stallionStorage.getIsMounted();
+          if(!currentProdSlot.equals(StallionConstants.DEFAULT_FOLDER_SLOT)) {
+            String currentHash = stallionStorage.get(StallionConstants.PROD_DIRECTORY + currentProdSlot);
+            WritableMap exceptionErrorPayload = Arguments.createMap();
+            exceptionErrorPayload.putString("error", stackTraceString);
+            exceptionErrorPayload.putString("releaseHash", currentHash);
+            exceptionErrorPayload.putString("isAutoRollback", Boolean.toString(isAutoRollback));
+            StallionEventEmitter.cacheEvent(
+              StallionEventEmitter.getEventPayload(
+                StallionConstants.NativeEventTypesProd.EXCEPTION_PROD.toString(),
+                exceptionErrorPayload
+              )
+            );
+          }
+          if(isAutoRollback) {
+            StallionRollbackManager.rollbackProd(true);
+          }
+          continueExceptionFlow();
+        } else if(switchState.equals(StallionConstants.SwitchState.STAGE.toString())) {
+          StallionRollbackManager.rollbackStage();
           Activity currentActivity = _currentContext.getCurrentActivity();
           if(currentActivity != null) {
             Intent myIntent = new Intent(currentActivity, StallionDefaultErrorActivity.class);

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

@@ -0,0 +1,144 @@
+package com.stallion;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Objects;
+
+public class StallionEventEmitter {
+  private static ArrayList<WritableMap> pendingEvents = new ArrayList<WritableMap>();
+  private static final String CACHE_EVENTS_KEY = "cached_pending_events";
+
+  public static void triggerPendingEvents() {
+    loadCachedEvents();
+    for(WritableMap pendingEvent : pendingEvents) {
+      triggerEvent(pendingEvent);
+    }
+    pendingEvents.clear();
+    clearCachedEvents();
+  }
+
+  public static void sendEvent(WritableMap payload) {
+    if(StallionStorage.getInstance().getIsMounted()) {
+      triggerEvent(payload);
+    } else {
+      pendingEvents.add(payload);
+    }
+  }
+
+  private static void triggerEvent(WritableMap payload) {
+    ReactApplicationContext reactContext = (ReactApplicationContext) StallionStorage.getInstance().mContext;
+    DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    eventEmitter.emit(StallionConstants.STALLION_NATIVE_EVENT_NAME, payload);
+  }
+
+  public static WritableMap getEventPayload(String eventName, WritableMap eventValue) {
+    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+    String stallionAppVersionCache = stallionStorageInstance.get(StallionConstants.STALLION_APP_VERSION_IDENTIFIER);
+    WritableMap params = Arguments.createMap();
+    eventValue.putString("AppVersion", stallionAppVersionCache);
+    params.putString("type", eventName);
+    params.putMap("payload", eventValue);
+    return  params;
+  }
+
+  public static void cacheEvent(WritableMap payload) {
+    try {
+      StallionStorage stallionStorage = StallionStorage.getInstance();
+      String cachedEventsJson = stallionStorage.get(CACHE_EVENTS_KEY);
+      String newEvent = readableMapToString(payload);
+
+      // Concatenate the new event with existing ones, separated by a delimiter
+      String updatedEvents = cachedEventsJson.isEmpty() ? newEvent : cachedEventsJson + "|" + newEvent;
+      stallionStorage.set(CACHE_EVENTS_KEY, updatedEvents);
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static void loadCachedEvents() {
+    try {
+      StallionStorage stallionStorage = StallionStorage.getInstance();
+      String cachedEvents = stallionStorage.get(CACHE_EVENTS_KEY);
+
+      if (!cachedEvents.isEmpty()) {
+        String[] eventArray = cachedEvents.split("\\|");
+        for (String eventString : eventArray) {
+          WritableMap eventMap = stringToWritableMap(eventString);
+          pendingEvents.add(eventMap);
+        }
+      }
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static void clearCachedEvents() {
+    StallionStorage stallionStorage = StallionStorage.getInstance();
+    stallionStorage.set(CACHE_EVENTS_KEY, "");
+  }
+
+  // Convert WritableMap to String (JSON)
+  public static String readableMapToString(ReadableMap map) throws JSONException {
+    JSONObject jsonObject = new JSONObject();
+    ReadableMapKeySetIterator iterator = map.keySetIterator();
+
+    while (iterator.hasNextKey()) {
+      String key = iterator.nextKey();
+      switch (map.getType(key)) {
+        case String:
+          jsonObject.put(key, map.getString(key));
+          break;
+        case Map:
+          jsonObject.put(key, new JSONObject(readableMapToString(Objects.requireNonNull(map.getMap(key)))));
+          break;
+        case Boolean:
+          jsonObject.put(key, map.getBoolean(key));
+          break;
+        case Number:
+          jsonObject.put(key, map.getDouble(key));
+          break;
+        case Null:
+          jsonObject.put(key, JSONObject.NULL);
+          break;
+      }
+    }
+    return jsonObject.toString();
+  }
+
+  // Convert String (JSON) back to WritableMap
+  public static WritableMap stringToWritableMap(String jsonString) throws JSONException {
+    JSONObject jsonObject = new JSONObject(jsonString);
+    WritableMap map = new WritableNativeMap();
+
+    Iterator<String> keys = jsonObject.keys();
+    while (keys.hasNext()) {
+      String key = keys.next();
+      Object value = jsonObject.get(key);
+
+      if (value instanceof JSONObject) {
+        map.putMap(key, stringToWritableMap(value.toString()));
+      } else if (value instanceof Boolean) {
+        map.putBoolean(key, (Boolean) value);
+      } else if (value instanceof Number) {
+        map.putDouble(key, ((Number) value).doubleValue());
+      } else if (value instanceof String) {
+        map.putString(key, (String) value);
+      } else if (value == JSONObject.NULL) {
+        map.putNull(key);
+      }
+    }
+    return map;
+  }
+
+}