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

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

@@ -1,110 +1,170 @@
 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 com.stallion.events.StallionEventConstants;
+import com.stallion.events.StallionEventManager;
+import com.stallion.storage.StallionConfigConstants;
+import com.stallion.storage.StallionStateManager;
+import com.stallion.storage.StallionMeta;
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.utils.StallionFileManager;
+import com.stallion.utils.StallionSlotManager;
+
+import org.json.JSONObject;
 
 import java.io.File;
 
 public class Stallion {
 
+  private static StallionStateManager stateManager;
+
   public static String getJSBundleFile(Context applicationContext) {
     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;
+  public static String getJSBundleFile(Context applicationContext, String defaultBundlePath) {
+    StallionStateManager.init(applicationContext);
+    stateManager = StallionStateManager.getInstance();
+
+    validateAppVersion(stateManager.getStallionConfig().getAppVersion());
+
+    StallionEventManager.init(stateManager);
+
+    String baseFolderPath = stateManager.getStallionConfig().getFilesDirectory();
+    StallionMeta stallionMeta = stateManager.stallionMeta;
+    StallionMetaConstants.SwitchState switchState = stallionMeta.getSwitchState();
+
+    if (switchState == StallionMetaConstants.SwitchState.PROD) {
+      return getProdBundlePath(baseFolderPath, defaultBundlePath);
+    } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
+      return getStageBundlePath(baseFolderPath, defaultBundlePath);
+    }
+    return getDefaultBundle(defaultBundlePath);
+  }
+
+  private static void validateAppVersion(String currentAppVersion) {
+    StallionStateManager stallionStateManager = StallionStateManager.getInstance();
+    String cachedAppVersion = stallionStateManager.getString(StallionConfigConstants.STALLION_APP_VERSION_IDENTIFIER, "");;
+    if (
+      currentAppVersion != null
+        && !currentAppVersion.isEmpty()
+        && !cachedAppVersion.equals(currentAppVersion)
+    ) {
+      stallionStateManager.setString(StallionConfigConstants.STALLION_APP_VERSION_IDENTIFIER, currentAppVersion);
+      StallionSlotManager.fallbackProd();
     }
   }
 
-  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 mountNewProdBundle(String baseFolderPath) {
+    StallionMeta stallionMeta = stateManager.stallionMeta;
+    String prodTempHash = stallionMeta.getProdTempHash();
+    if(prodTempHash != null && !prodTempHash.isEmpty()) {
+      try {
+        StallionFileManager.moveFile(
+          new File(baseFolderPath, StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.TEMP_FOLDER_SLOT),
+          new File(baseFolderPath, StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT)
+        );
+        stallionMeta.setProdNewHash(prodTempHash);
+        stallionMeta.setProdTempHash("");
+        stateManager.syncStallionMeta();
+        sendInstallEvent(prodTempHash);
+      } catch (Exception ignored) {}
+    }
   }
 
-  private static void sendInstallEvent(String installedReleaseHash) {
-    WritableMap successEventPayload = Arguments.createMap();
-    successEventPayload.putString("releaseHash", installedReleaseHash);
-    StallionEventEmitter.sendEvent(
-      StallionEventEmitter.getEventPayload(
-        StallionConstants.NativeEventTypesProd.INSTALLED_PROD.toString(),
-        successEventPayload
-      )
-    );
+  private static void mountNewStageBundle(String baseFolderPath) {
+    StallionMeta stallionMeta = stateManager.stallionMeta;
+    String stageTempHash = stallionMeta.getStageTempHash();
+    if(stageTempHash != null && !stageTempHash.isEmpty()) {
+      try {
+        StallionFileManager.moveFile(
+          new File(baseFolderPath, StallionConfigConstants.STAGE_DIRECTORY + StallionConfigConstants.TEMP_FOLDER_SLOT),
+          new File(baseFolderPath, StallionConfigConstants.STAGE_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT)
+        );
+        stallionMeta.setStageNewHash(stageTempHash);
+        stallionMeta.setStageTempHash("");
+        stateManager.syncStallionMeta();
+      } catch (Exception ignored) {}
+    }
   }
 
-  public static String getJSBundleFile(Context applicationContext, String defaultBundlePath) {
-    StallionStorage.getInstance().Initialize(applicationContext);
-    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
-    String baseFolderPath = applicationContext.getFilesDir().getAbsolutePath();
-    String switchState = stallionStorageInstance.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
-    String currentAppVersion = "";
+  private static String getProdBundlePath(String baseFolderPath, String defaultBundlePath) {
+    StallionMeta stallionMeta = stateManager.stallionMeta;
+
+    mountNewProdBundle(baseFolderPath);
+
+    switch (stallionMeta.getCurrentProdSlot()) {
+      case NEW_SLOT:
+        return resolveBundlePath(baseFolderPath + StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT, defaultBundlePath, stallionMeta.getProdNewHash(), true);
+      case STABLE_SLOT:
+        return resolveBundlePath(baseFolderPath + StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.STABLE_FOLDER_SLOT, defaultBundlePath, stallionMeta.getProdStableHash(), true);
+      default:
+        return getDefaultBundle(defaultBundlePath);
+    }
+  }
+
+  private static String getStageBundlePath(String baseFolderPath, String defaultBundlePath) {
+    StallionMeta stallionMeta = stateManager.stallionMeta;
+
+    mountNewStageBundle(baseFolderPath);
+
+    switch (stallionMeta.getCurrentStageSlot()) {
+      case NEW_SLOT:
+        return resolveBundlePath(baseFolderPath + StallionConfigConstants.STAGE_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT, defaultBundlePath, stallionMeta.getStageNewHash(), false);
+      default:
+        return getDefaultBundle(defaultBundlePath);
+    }
+  }
+
+  private static void sendInstallEvent(String releaseHash) {
     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();
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", releaseHash);
+
+      StallionEventManager.getInstance().sendEvent(
+        StallionEventConstants.NativeProdEventTypes.INSTALLED_PROD.toString(),
+        eventPayload
+      );
+    } catch (Exception e) {
+      e.printStackTrace();
     }
-    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);
-      }
+  }
+
+  private static void sendCorruptionEvent(String releaseHash, String folderPath) {
+    try {
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", releaseHash);
+      eventPayload.put("meta", folderPath);
+
+      StallionEventManager.getInstance().sendEvent(
+        StallionEventConstants.NativeProdEventTypes.CORRUPTED_FILE_ERROR.toString(),
+        eventPayload
+      );
+    } catch (Exception e) {
+      e.printStackTrace();
     }
-    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);
+  }
+
+  private static String resolveBundlePath(String folderPath, String defaultBundlePath, String releaseHash, Boolean isProd) {
+    String bundlePath = folderPath + StallionConfigConstants.UNZIP_FOLDER_NAME + StallionConfigConstants.ANDROID_BUNDLE_FILE_NAME;
+    if (new File(bundlePath).exists()) {
+      return bundlePath;
+    } else {
+      if(isProd) {
+        StallionSlotManager.rollbackProd(true, "Corruped file not found" + folderPath);
+        sendCorruptionEvent(releaseHash, folderPath);
+      } else {
+        StallionSlotManager.rollbackStage();
       }
+      return getDefaultBundle(defaultBundlePath);
     }
-    return getDefaultBundle(defaultBundlePath);
+  }
+
+  private static String getDefaultBundle(String defaultBundlePath) {
+    return defaultBundlePath != null && !defaultBundlePath.isEmpty()
+      ? defaultBundlePath
+      : StallionConfigConstants.DEFAULT_JS_BUNDLE_LOCATION_BASE + StallionConfigConstants.ANDROID_BUNDLE_FILE_NAME;
   }
 }
+

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

@@ -1,40 +1,46 @@
 package com.stallion;
 
-import android.content.res.Resources;
-
 import androidx.annotation.NonNull;
 
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 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.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.stallion.events.StallionEventManager;
+import com.stallion.networkmanager.StallionStageManager;
+import com.stallion.networkmanager.StallionSyncHandler;
+import com.stallion.storage.StallionConfigConstants;
+
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.storage.StallionStateManager;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.util.ArrayList;
+import java.util.List;
+
 
-@ReactModule(name = StallionConstants.MODULE_NAME)
+@ReactModule(name = StallionConfigConstants.MODULE_NAME)
 public class StallionModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
   private final ReactApplicationContext currentReactContext;
-  private final StallionStorage stallionStorage;
-  private DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter;
+  private final StallionStateManager stallionStateManager;
 
   public StallionModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    StallionStateManager.init(reactContext);
+    this.stallionStateManager = StallionStateManager.getInstance();
     this.currentReactContext = reactContext;
-    StallionStorage.getInstance().Initialize(reactContext);
-    this.stallionStorage = StallionStorage.getInstance();
-    StallionErrorBoundary.initErrorBoundary(reactContext);
-    StallionErrorBoundary.toggleExceptionHandler(true);
     reactContext.addLifecycleEventListener(this);
   }
 
   @Override
   public void onHostResume() {
-    StallionSynManager.sync();
+    StallionSyncHandler.sync();
   }
 
   @Override
@@ -52,106 +58,113 @@ public class StallionModule extends ReactContextBaseJavaModule implements Lifecy
   @Override
   @NonNull
   public String getName() {
-    return StallionConstants.MODULE_NAME;
+    return StallionConfigConstants.MODULE_NAME;
   }
 
   @ReactMethod
-  public void setStorage(String key, String value) {
-    this.stallionStorage.set(key, value);
+  public void onLaunch(String launchData) {
+    stallionStateManager.setIsMounted(true);
+
+    DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = this.currentReactContext.getJSModule(
+      DeviceEventManagerModule.RCTDeviceEventEmitter.class
+    );
+    StallionEventManager.getInstance().setEmitter(eventEmitter);
+
+    checkPendingDownloads();
   }
 
+  private void checkPendingDownloads() {
+    String pendingReleaseUrl = stallionStateManager.getPendingReleaseUrl();
+    String pendingReleaseHash = stallionStateManager.getPendingReleaseHash();
+    if(!pendingReleaseUrl.isEmpty() && !pendingReleaseHash.isEmpty()) {
+      StallionSyncHandler.downloadNewRelease(pendingReleaseHash, pendingReleaseUrl);
+      stallionStateManager.setPendingRelease("", "");
+    }
+  }
 
   @ReactMethod
-  public void getStorage(String key, Callback callback) {
-    callback.invoke(this.stallionStorage.get(key));
+  public void getStallionConfig(Promise promise) {
+    try {
+      String stallionConfigJsonString = stallionStateManager.getStallionConfig().toJSON().toString();
+      promise.resolve(stallionConfigJsonString);
+    } catch (Exception e) {
+      promise.reject("getStallionConfig error:", e.toString());
+    }
   }
 
   @ReactMethod
-  public void onLaunch(String launchData) {
-    StallionStorage.getInstance().setIsMounted();
-    StallionEventEmitter.triggerPendingEvents();
+  public void getStallionMeta(Promise promise) {
+    try {
+      String stallionMetaJsonString = stallionStateManager.stallionMeta.toJSON().toString();
+      promise.resolve(stallionMetaJsonString);
+    } catch (Exception e) {
+      promise.reject("getStallionMeta error:", e.toString());
+    }
   }
 
   @ReactMethod
-  public  void  getUniqueId(Callback callback) {
-    callback.invoke(StallionCommonUtil.getUniqueId());
+  public void toggleStallionSwitch(String switchState, Promise promise) {
+    try {
+      stallionStateManager.stallionMeta.setSwitchState(StallionMetaConstants.SwitchState.fromString(switchState));
+      stallionStateManager.syncStallionMeta();
+      promise.resolve("Success");
+    } catch (Exception e) {
+      promise.reject("toggleStallionSwitch error:", e.toString());
+    }
   }
 
   @ReactMethod
-  public void getProjectId(Callback callback) {
-    Resources res = currentReactContext.getResources();
-    String parentPackageName= currentReactContext.getPackageName();
-    int stallionProjectIdRes = res.getIdentifier(StallionConstants.STALLION_PROJECT_ID_IDENTIFIER, "string", parentPackageName);
-    String projectId = currentReactContext.getString(stallionProjectIdRes);
-    callback.invoke(projectId);
+  public void updateSdkToken(String newSdkToken, Promise promise) {
+    try {
+      stallionStateManager.getStallionConfig().updateSdkToken(newSdkToken);
+      promise.resolve("updateSdkToken success");
+    } catch (Exception e) {
+      promise.reject("updateSdkToken error:", e.toString());
+    }
   }
 
   @ReactMethod
-  public void getAppToken(Callback callback) {
-    Resources res = currentReactContext.getResources();
-    String parentPackageName= currentReactContext.getPackageName();
-    int stallionAppTokenRes = res.getIdentifier(StallionConstants.STALLION_APP_TOKEN_IDENTIFIER, "string", parentPackageName);
-    String appToken = currentReactContext.getString(stallionAppTokenRes);
-    callback.invoke(appToken);
+  public  void  sync() {
+    StallionSyncHandler.sync();
   }
 
   @ReactMethod
-  public  void  sync() {
-    StallionSynManager.sync();
+  public void downloadStageBundle(ReadableMap bundleInfo, Promise promise) {
+    StallionStageManager.downloadStageBundle(bundleInfo, promise);
   }
 
   @ReactMethod
-  public void downloadPackage(ReadableMap bundleInfo, Promise promise) {
-    String receivedDownloadUrl = bundleInfo.getString("url");
-    String receivedHash = bundleInfo.getString("hash");
-    String sdkToken = stallionStorage.get(StallionConstants.STALLION_SDK_TOKEN_KEY);
-    StallionDownloadManager.downloadBundle(
-      receivedDownloadUrl,
-      this.currentReactContext.getFilesDir().getAbsolutePath() + StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT,
-      sdkToken,
-      "",
-      new StallionDownloadCallback() {
-        @Override
-        public void onReject(String prefix, String error) {
-          WritableMap errorEventPayload = Arguments.createMap();
-          errorEventPayload.putString("releaseHash", receivedHash);
-          StallionEventEmitter.sendEvent(
-            StallionEventEmitter.getEventPayload(
-              StallionConstants.NativeEventTypesStage.DOWNLOAD_ERROR_STAGE.toString(),
-              errorEventPayload
-            )
-          );
-          promise.reject(prefix, error);
-        }
-
-        @Override
-        public void onSuccess(String successPayload) {
-          stallionStorage.set(StallionConstants.CURRENT_STAGE_SLOT_KEY, StallionConstants.TEMP_FOLDER_SLOT);
-          stallionStorage.set(StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, receivedHash);
-          WritableMap successEventPayload = Arguments.createMap();
-          successEventPayload.putString("releaseHash", receivedHash);
-          StallionEventEmitter.sendEvent(
-            StallionEventEmitter.getEventPayload(
-              StallionConstants.NativeEventTypesStage.DOWNLOAD_COMPLETE_STAGE.toString(),
-              successEventPayload
-            )
-          );
-          promise.resolve(StallionConstants.DOWNLOAD_SUCCESS_MESSAGE);
-        }
-
-        @Override
-        public void onProgress(double downloadFraction) {
-          WritableMap progressEventPayload = Arguments.createMap();
-          progressEventPayload.putString("releaseHash", receivedHash);
-          progressEventPayload.putDouble("progress", downloadFraction);
-          StallionEventEmitter.sendEvent(
-            StallionEventEmitter.getEventPayload(
-              StallionConstants.NativeEventTypesStage.DOWNLOAD_PROGRESS_STAGE.toString(),
-              progressEventPayload
-            )
-          );
-        }
+  public void popEvents(Promise promise) {
+    try {
+      promise.resolve(StallionEventManager.getInstance().popEvents());
+    } catch (Exception e) {
+      promise.reject("popEvents error: ", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void acknowledgeEvents(String eventIdsJson, Promise promise) {
+    try {
+      // Parse the stringified JSON array into a Java List
+      JSONArray jsonArray = new JSONArray(eventIdsJson);
+      List<String> eventIds = new ArrayList<>();
+
+      for (int i = 0; i < jsonArray.length(); i++) {
+        eventIds.add(jsonArray.getString(i));
       }
-    );
+
+      // Use StallionEventManager to acknowledge the events
+      StallionEventManager eventManager = StallionEventManager.getInstance();
+      eventManager.acknowledgeEvents(eventIds);
+
+      // Resolve the promise indicating success
+      promise.resolve("Events acknowledged successfully.");
+    } catch (JSONException e) {
+      // Reject the promise if JSON parsing fails
+      promise.reject("ACKNOWLEDGE_EVENTS_JSON_ERROR", "Invalid JSON format for event IDs: " + e.getMessage(), e);
+    } catch (Exception e) {
+      // Reject the promise for other errors
+      promise.reject("ACKNOWLEDGE_EVENTS_ERROR", "Failed to acknowledge events: " + e.getMessage(), e);
+    }
   }
 }

package/android/src/main/java/com/stallion/events/StallionEventConstants.java

@@ -0,0 +1,22 @@
+package com.stallion.events;
+
+public class StallionEventConstants {
+  public enum NativeProdEventTypes {
+    DOWNLOAD_STARTED_PROD,
+    DOWNLOAD_ERROR_PROD,
+    DOWNLOAD_COMPLETE_PROD,
+    SYNC_ERROR_PROD,
+    ROLLED_BACK_PROD,
+    INSTALLED_PROD,
+    STABILIZED_PROD,
+    EXCEPTION_PROD,
+    AUTO_ROLLED_BACK_PROD,
+    CORRUPTED_FILE_ERROR
+  }
+
+  public enum NativeStageEventTypes {
+    DOWNLOAD_PROGRESS_STAGE,
+    DOWNLOAD_COMPLETE_STAGE,
+    EXCEPTION_STAGE
+  }
+}