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

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

@@ -2,25 +2,169 @@ package com.stallion;
 
 import android.content.Context;
 
+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);
   }
 
   public static String getJSBundleFile(Context applicationContext, String defaultBundlePath) {
-    StallionStorage.getInstance().Initialize(applicationContext);
-    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+    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 (
-      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)
+      currentAppVersion != null
+        && !currentAppVersion.isEmpty()
+        && !cachedAppVersion.equals(currentAppVersion)
     ) {
-      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;
+      stallionStateManager.setString(StallionConfigConstants.STALLION_APP_VERSION_IDENTIFIER, currentAppVersion);
+      StallionSlotManager.fallbackProd();
+    }
+  }
+
+  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 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) {}
+    }
+  }
+
+  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 {
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", releaseHash);
+
+      StallionEventManager.getInstance().sendEvent(
+        StallionEventConstants.NativeProdEventTypes.INSTALLED_PROD.toString(),
+        eventPayload
+      );
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  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();
+    }
+  }
+
+  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 (defaultBundlePath != null) return defaultBundlePath;
-      return StallionConstants.DEFAULT_JS_BUNDLE_LOCATION_BASE + StallionConstants.ANDROID_BUNDLE_FILE_NAME;
+      if(isProd) {
+        StallionSlotManager.rollbackProd(true, "Corruped file not found" + folderPath);
+        sendCorruptionEvent(releaseHash, folderPath);
+      } else {
+        StallionSlotManager.rollbackStage();
+      }
+      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

@@ -2,210 +2,171 @@ package com.stallion;
 
 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 android.util.Log;
-
-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;
-
-@ReactModule(name = StallionConstants.MODULE_NAME)
-public class StallionModule extends ReactContextBaseJavaModule {
-  private ReactApplicationContext currentReactContext;
-  private String baseDir;
-  private StallionStorage stallionStorage;
-  private DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter;
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.storage.StallionStateManager;
+import com.stallion.utils.StallionExceptionHandler;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+@ReactModule(name = StallionConfigConstants.MODULE_NAME)
+public class StallionModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
+  private final ReactApplicationContext currentReactContext;
+  private final StallionStateManager stallionStateManager;
 
   public StallionModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    StallionStateManager.init(reactContext);
+    this.stallionStateManager = StallionStateManager.getInstance();
     this.currentReactContext = reactContext;
-    this.baseDir = reactContext.getFilesDir().getAbsolutePath() + StallionConstants.STALLION_PACKAGE_PATH;
-    StallionStorage.getInstance().Initialize(reactContext);
-    this.stallionStorage = StallionStorage.getInstance();
-    StallionErrorBoundary.initErrorBoundary(reactContext);
-    String switchState = this.stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
-    Boolean isStallionEnabled = switchState == null ? false : switchState.equals(StallionConstants.STALLION_SWITCH_ON);
-    StallionErrorBoundary.toggleExceptionHandler(isStallionEnabled);
+    StallionExceptionHandler.initErrorBoundary(reactContext);
+    reactContext.addLifecycleEventListener(this);
+  }
+
+  @Override
+  public void onHostResume() {
+    StallionSyncHandler.sync();
+  }
+
+  @Override
+  public void onHostPause() {}
+
+  @Override
+  public void onHostDestroy() {}
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy();
+    this.currentReactContext.removeLifecycleEventListener(this);
   }
 
   @Override
   @NonNull
   public String getName() {
-    return StallionConstants.MODULE_NAME;
+    return StallionConfigConstants.MODULE_NAME;
   }
 
   @ReactMethod
-  public void setApiKey(String apiKey) {
-    this.stallionStorage.set(StallionConstants.API_KEY_IDENTIFIER, apiKey);
+  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 getApiKey(Callback callback) {
-    callback.invoke(
-      this.stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER)
-    );
+  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 getStallionMeta(Callback callback) {
-    WritableMap bundleMeta = Arguments.createMap();
-    String activeBucket = this.stallionStorage.get(StallionConstants.ACTIVE_BUCKET_IDENTIFIER);
-    String switchState = this.stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
-    int activeVersion = this.stallionStorage.getInt(StallionConstants.ACTIVE_VERSION_IDENTIFIER);
-
-    bundleMeta.putString(StallionConstants.ACTIVE_BUCKET_IDENTIFIER, activeBucket);
-    bundleMeta.putBoolean(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER,
-      switchState == null ? false : switchState.equals(StallionConstants.STALLION_SWITCH_ON)
-    );
-    bundleMeta.putString(StallionConstants.ACTIVE_VERSION_IDENTIFIER, String.valueOf(activeVersion));
-    callback.invoke(bundleMeta);
+  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 toggleStallionSwitch(Boolean stallionBundleIsOn) {
-    this.stallionStorage.set(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER, stallionBundleIsOn ? StallionConstants.STALLION_SWITCH_ON : StallionConstants.STALLION_SWITCH_OFF);
+  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());
+    }
   }
 
-  private DeviceEventManagerModule.RCTDeviceEventEmitter getEventEmitter() {
-    if(this.eventEmitter == null) {
-      this.eventEmitter = this.currentReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+  @ReactMethod
+  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());
     }
-    return this.eventEmitter;
   }
 
   @ReactMethod
-  public void downloadPackage(ReadableMap bundleInfo, Promise promise) {
-    String receivedBucketId = bundleInfo.getString("bucketId");
-    String receivedDownloadUrl = bundleInfo.getString("url");
-    Integer receivedVersion = bundleInfo.getInt("version");
-
-    ExecutorService executor = Executors.newSingleThreadExecutor();
-
-    executor.execute(() -> {
-      DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter =  getEventEmitter();
-
-      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(receivedDownloadUrl);
-        connection = (HttpURLConnection) url.openConnection();
-        connection.setRequestMethod( "GET" );
-        connection.setRequestProperty("x-sdk-access-token", stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER));
-        connection.setRequestProperty("Content-Type", "application/json");
-
-        connection.setDoInput(true);
-
-        connection.connect();
-        inputStream = new BufferedInputStream(connection.getInputStream());
-        File downloadFolder = new File(baseDir + StallionConstants.DOWNLOAD_FOLDER_DIR);
-        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;
-            getReactApplicationContext().runOnUiQueueThread(() -> getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(StallionConstants.DOWNLOAD_PROGRESS_EVENT, currentDownloadFraction));
-          }
-        }
-
-        isZip = ByteBuffer.wrap(header).getInt() == 0x504b0304;
-        Log.d("", String.valueOf(isZip));
-
-      } catch (Exception e) {
-        promise.reject(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) {
-          promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_API_ERROR_MESSAGE);
-        }
-      }
+  public  void  sync() {
+    StallionSyncHandler.sync();
+  }
 
-      if (!isZip) {
-        promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, "Not a zip file");
-        return;
-      }
+  @ReactMethod
+  public void downloadStageBundle(ReadableMap bundleInfo, Promise promise) {
+    StallionStageManager.downloadStageBundle(bundleInfo, promise);
+  }
 
-      try {
-        int currentActiveSlot = stallionStorage.getInt(StallionConstants.ACTIVE_SLOT_IDENTIFIER);
-        int targetSlot;
-        if(currentActiveSlot == 1) {
-          targetSlot = 2;
-        } else if(currentActiveSlot == 2) {
-          targetSlot = 1;
-        } else {
-          targetSlot = 1;
-        }
-        StallionZip.unzipFile(downloadedZip.getAbsolutePath(), baseDir + StallionConstants.BUNDLE_DEST_FOLDER_DIR + StallionConstants.SLOT_FOLDER_DIR + targetSlot);
-        // setting active bucket ID, slot and version after downloading and all other jobs done
-        stallionStorage.setInt(StallionConstants.ACTIVE_SLOT_IDENTIFIER, targetSlot);
-        stallionStorage.set(StallionConstants.ACTIVE_BUCKET_IDENTIFIER, receivedBucketId);
-        if (receivedVersion != null) {
-          stallionStorage.setInt(StallionConstants.ACTIVE_VERSION_IDENTIFIER, receivedVersion);
-        }
-        promise.resolve(StallionConstants.DOWNLOAD_SUCCESS_MESSAGE);
-        getReactApplicationContext().runOnUiQueueThread(() -> getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(StallionConstants.DOWNLOAD_PROGRESS_EVENT, 1));
-      } catch (Exception e) {
-        promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_FILESYSTEM_ERROR_MESSAGE);
-      } finally {
-        try {
-          StallionZip.deleteFileOrFolderSilently(downloadedZip);
-        } catch (Exception e) {
-          promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_DELETE_ERROR);
-        }
-        return;
+  @ReactMethod
+  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
+  }
+}