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

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

@@ -0,0 +1,160 @@
+package com.stallion.events;
+
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.stallion.storage.StallionConfig;
+import com.stallion.storage.StallionConfigConstants;
+import com.stallion.storage.StallionStateManager;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+
+public class StallionEventManager {
+  public  static final String STALLION_NATIVE_EVENT_NAME = "STALLION_NATIVE_EVENT";
+  private static final String EVENTS_KEY = "stored_events";
+  private static final int MAX_BATCH_COUNT_SIZE = 9;
+
+  private static StallionEventManager instance;
+  private final StallionStateManager stallionStateManager;
+  private DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter;
+
+  // Private constructor for Singleton
+  private StallionEventManager(StallionStateManager stateManager) {
+    this.stallionStateManager = stateManager;
+  }
+
+  // Singleton initialization method
+  public static synchronized void init(StallionStateManager stateManager) {
+    if (instance == null) {
+      instance = new StallionEventManager(stateManager);
+    }
+  }
+
+  public void setEmitter(DeviceEventManagerModule.RCTDeviceEventEmitter deviceEmitter) {
+    eventEmitter = deviceEmitter;
+  }
+
+  // Get instance method
+  public static synchronized StallionEventManager getInstance() {
+    if (instance == null) {
+      throw new IllegalStateException("StallionEventManager is not initialized. Call init() first.");
+    }
+    return instance;
+  }
+
+  public void sendEventWithoutCaching(String eventName, JSONObject eventPayload) {
+    try {
+      eventPayload.put("type", eventName);
+
+      // Emit the event to React Native
+      if (eventEmitter != null) {
+        eventEmitter.emit(STALLION_NATIVE_EVENT_NAME, eventPayload.toString());
+      }
+
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+  // Method to send an event
+  public void sendEvent(String eventName, JSONObject eventPayload) {
+    try {
+      StallionConfig stallionConfig = this.stallionStateManager.getStallionConfig();
+      // Generate a unique ID for the event
+      String uniqueId = UUID.randomUUID().toString();
+
+      eventPayload.put("type", eventName);
+
+      // Emit the event to React Native
+      if (eventEmitter != null) {
+        eventEmitter.emit(STALLION_NATIVE_EVENT_NAME, eventPayload.toString());
+      }
+
+      // change type for sending to server
+      eventPayload.remove("type");
+      eventPayload.put("eventType", eventName);
+
+      // Add unique ID and timestamp to the event payload
+      eventPayload.put("eventId", uniqueId);
+      eventPayload.put("eventTimestamp", System.currentTimeMillis());
+      eventPayload.put("projectId", stallionConfig.getProjectId());
+      eventPayload.put("platform", StallionConfigConstants.PLATFORM);
+      eventPayload.put("appVersion", stallionConfig.getAppVersion());
+      eventPayload.put("uid", stallionConfig.getUid());
+
+      // Store the event locally
+      storeEventLocally(uniqueId, eventPayload);
+
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+  // Store the event locally in SharedPreferences
+  private void storeEventLocally(String uniqueId, JSONObject eventPayload) {
+    try {
+      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      JSONObject eventsObject = new JSONObject(eventsString);
+      eventsObject.put(uniqueId, eventPayload.toString());
+      stallionStateManager.setString(EVENTS_KEY, eventsObject.toString());
+    } catch (JSONException e) {
+      cleanupEventStorage();
+      e.printStackTrace();
+    }
+  }
+
+  private void cleanupEventStorage() {
+    stallionStateManager.setString(EVENTS_KEY, "{}");
+  }
+
+  // Method to pop events as a batch
+  public String popEvents() {
+    try {
+      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      JSONObject eventsObject = new JSONObject(eventsString);
+
+      JSONArray batch = new JSONArray();
+      Iterator<String> keys = eventsObject.keys();
+
+      int count = 0;
+      while (keys.hasNext() && count < MAX_BATCH_COUNT_SIZE) {
+        String key = keys.next();
+        batch.put(new JSONObject(eventsObject.getString(key)));
+        count++;
+      }
+
+      return batch.toString();
+
+    } catch (JSONException e) {
+      cleanupEventStorage();
+      e.printStackTrace();
+    }
+
+    return "[]"; // Return an empty array if there are no events
+  }
+
+  // Acknowledge events by deleting them from local storage
+  public void acknowledgeEvents(List<String> eventIds) {
+    try {
+      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      JSONObject eventsObject = new JSONObject(eventsString);
+
+      // Remove each event by its unique ID
+      for (String eventId : eventIds) {
+        if (eventsObject.has(eventId)) {
+          eventsObject.remove(eventId);
+        }
+      }
+
+      // Update the SharedPreferences with the modified events
+      stallionStateManager.setString(EVENTS_KEY, eventsObject.toString());
+
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+}

package/android/src/main/java/com/stallion/networkmanager/StallionApiConstants.java

@@ -0,0 +1,28 @@
+package com.stallion.networkmanager;
+
+public class StallionApiConstants {
+  // Buffer Size
+  public static final int DOWNLOAD_BUFFER_SIZE = 1024 * 256;
+
+  // File and Folder Names
+  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";
+
+  // Error Messages
+  public static final String DOWNLOAD_ERROR_PREFIX = "Stallion download error: ";
+  public static final String DOWNLOAD_FILESYSTEM_ERROR_MESSAGE = "Filesystem error in download";
+  public static final String CORRUPTED_FILE_ERROR = "Corrupted file";
+
+  // Success Messages
+  public static final String DOWNLOAD_SUCCESS_MESSAGE = "Success";
+
+  // API Tokens
+  public static final String STALLION_APP_TOKEN_KEY = "x-app-token";
+  public static final String STALLION_SDK_TOKEN_KEY = "x-sdk-pin-access-token";
+  public static final String STALLION_DEVICE_ID_KEY = "uid";
+
+
+  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";
+}

package/android/src/main/java/com/stallion/networkmanager/StallionApiManager.java

@@ -0,0 +1,96 @@
+package com.stallion.networkmanager;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+
+import com.stallion.storage.StallionConfig;
+import com.stallion.storage.StallionStateManager;
+
+public class StallionApiManager {
+
+  public static JSONObject post(String urlString, String requestBodyString) {
+    HttpURLConnection urlConnection = null;
+    try {
+      StallionStateManager stallionStateManager = StallionStateManager.getInstance();
+      StallionConfig stallionConfig = stallionStateManager.getStallionConfig();
+
+      // Set up the connection
+      URL url = new URL(urlString);
+      urlConnection = (HttpURLConnection) url.openConnection();
+      urlConnection.setRequestMethod("POST");
+      urlConnection.setRequestProperty("Content-Type", "application/json");
+
+      String appToken = stallionConfig.getAppToken();
+      String sdkToken = stallionConfig.getSdkToken();
+      String uid = stallionConfig.getUid();
+
+      if(appToken != null && !appToken.isEmpty()) {
+        urlConnection.setRequestProperty(StallionApiConstants.STALLION_APP_TOKEN_KEY, appToken);
+      }
+
+      if (sdkToken != null && !sdkToken.isEmpty()) {
+        urlConnection.setRequestProperty(StallionApiConstants.STALLION_SDK_TOKEN_KEY, sdkToken);
+      }
+
+      if (uid != null && !uid.isEmpty()) {
+        urlConnection.setRequestProperty(StallionApiConstants.STALLION_DEVICE_ID_KEY, uid);
+      }
+
+      urlConnection.setDoOutput(true);
+
+      // Write the request body
+      try (OutputStream os = urlConnection.getOutputStream();
+           OutputStreamWriter osw = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
+        osw.write(requestBodyString);
+        osw.flush();
+      }
+
+      // Connect and check response code
+      int responseCode = urlConnection.getResponseCode();
+      if (responseCode != HttpURLConnection.HTTP_OK) {
+        throw new IOException("HTTP error code: " + responseCode);
+      }
+
+      // Read the response
+      StringBuilder result = new StringBuilder();
+      try (InputStream in = urlConnection.getInputStream();
+           BufferedReader reader = new BufferedReader(new InputStreamReader(in))) {
+        String line;
+        while ((line = reader.readLine()) != null) {
+          result.append(line);
+        }
+      }
+
+      // Parse and return JSON
+      return new JSONObject(result.toString());
+
+    } catch (Exception e) {
+      e.printStackTrace();
+
+      // Return an error JSON object
+      JSONObject error = new JSONObject();
+      try {
+        error.put("error", e.getMessage());
+      } catch (JSONException jsonException) {
+        jsonException.printStackTrace();
+      }
+      return error;
+
+    } finally {
+      if (urlConnection != null) {
+        urlConnection.disconnect();
+      }
+    }
+  }
+}
+

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

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

package/android/src/main/java/com/stallion/networkmanager/StallionFileDownloader.java

@@ -0,0 +1,224 @@
+package com.stallion.networkmanager;
+
+import android.os.StatFs;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+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;
+
+import android.util.Log;
+
+import com.stallion.storage.StallionConfig;
+import com.stallion.storage.StallionStateManager;
+import com.stallion.utils.StallionFileManager;
+
+public class StallionFileDownloader {
+
+  private static final String TAG = "StallionFileDownloader";
+  private static final ExecutorService executor = Executors.newSingleThreadExecutor();
+
+  public static void downloadBundle(
+    String downloadUrl,
+    String downloadDirectory,
+    StallionDownloadCallback stallionDownloadCallback
+  ) {
+    executor.execute(() -> {
+      try {
+        // Prepare for download
+        File downloadedZip = prepareForDownload(downloadDirectory);
+
+        // Fetch appToken and apiKey
+        StallionStateManager stateManager = StallionStateManager.getInstance();
+        StallionConfig config = stateManager.getStallionConfig();
+        String appToken = config.getAppToken();
+        String sdkToken = config.getSdkToken();
+
+        // Get file size
+        long fileSize = getFileSize(downloadUrl, appToken, sdkToken);
+        if (fileSize <= 0) {
+          stallionDownloadCallback.onReject(
+            StallionApiConstants.DOWNLOAD_ERROR_PREFIX,
+            "File size is zero or unknown"
+          );
+          return;
+        }
+
+        // Check available storage
+        if (!isEnoughSpaceAvailable(downloadDirectory, fileSize)) {
+          stallionDownloadCallback.onReject(
+            StallionApiConstants.DOWNLOAD_ERROR_PREFIX,
+            "Not enough space to download the file"
+          );
+          return;
+        }
+
+        // Download file
+        downloadFile(downloadUrl, downloadedZip, appToken, sdkToken, stallionDownloadCallback);
+
+        // Validate and unzip the downloaded file
+        validateAndUnzip(downloadedZip, downloadDirectory, stallionDownloadCallback);
+
+      } catch (Exception e) {
+        Log.e(TAG, "Error in downloadBundle: " + e.getMessage(), e);
+      }
+    });
+  }
+
+  private static long getFileSize(String downloadUrl, String appToken, String apiKey) throws IOException {
+    HttpURLConnection connection = null;
+    try {
+      connection = setupConnection(downloadUrl, appToken, apiKey);
+      return connection.getContentLength();
+    } finally {
+      if (connection != null) {
+        connection.disconnect();
+      }
+    }
+  }
+
+  private static boolean isEnoughSpaceAvailable(String directoryPath, long fileSize) {
+    File directory = new File(directoryPath);
+    if (!directory.exists()) {
+      directory.mkdirs();
+    }
+    StatFs statFs = new StatFs(directory.getPath());
+    long availableBytes = (long) statFs.getAvailableBlocksLong() * statFs.getBlockSizeLong();
+    return availableBytes >= fileSize;
+  }
+
+  private static File prepareForDownload(String downloadDirectory) throws IOException {
+    File downloadFolder = new File(downloadDirectory);
+    if (downloadFolder.exists()) {
+      StallionFileManager.deleteFileOrFolderSilently(downloadFolder);
+    }
+    if (!downloadFolder.mkdirs()) {
+      throw new IOException("Failed to create download directory: " + downloadDirectory);
+    }
+    return new File(downloadFolder, StallionApiConstants.ZIP_FILE_NAME);
+  }
+
+  private static void downloadFile(
+    String downloadUrl,
+    File destinationFile,
+    String appToken,
+    String sdkToken,
+    StallionDownloadCallback callback
+  ) throws IOException {
+    HttpURLConnection connection = null;
+    try (
+      BufferedInputStream inputStream = new BufferedInputStream(setupConnection(downloadUrl, appToken, sdkToken).getInputStream());
+      FileOutputStream fout = new FileOutputStream(destinationFile);
+      BufferedOutputStream bout = new BufferedOutputStream(fout, StallionApiConstants.DOWNLOAD_BUFFER_SIZE)
+    ) {
+      connection = setupConnection(downloadUrl, appToken, sdkToken);
+
+      byte[] buffer = new byte[StallionApiConstants.DOWNLOAD_BUFFER_SIZE];
+      long totalBytes = connection.getContentLength();
+      long receivedBytes = 0;
+      int bytesRead;
+      double lastProgress = 0;
+
+      // Ensure totalBytes is valid
+      if (totalBytes <= 0) {
+        callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, "Invalid content length: " + totalBytes);
+        return;
+      }
+
+      while ((bytesRead = inputStream.read(buffer)) != -1) {
+        bout.write(buffer, 0, bytesRead);
+        receivedBytes += bytesRead;
+
+        double progress = (double) receivedBytes / totalBytes;
+        if (Double.isNaN(progress) || Double.isInfinite(progress)) {
+          callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, "Invalid progress calculation");
+          return;
+        }
+
+        if (progress - lastProgress >= 0.1) {
+          lastProgress = progress;
+          callback.onProgress(progress);
+        }
+      }
+
+      bout.close();
+      fout.close();
+      inputStream.close();
+
+      // Check for incomplete download
+      if (receivedBytes < totalBytes) {
+        callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, "Incomplete file download");
+        return;
+      }
+    } catch (IOException e) {
+      callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, "IOException occurred: " + e.getMessage());
+      throw e;
+    } finally {
+      if (connection != null) {
+        connection.disconnect();
+      }
+    }
+  }
+
+
+  private static HttpURLConnection setupConnection(String downloadUrl, String appToken, String sdkToken) throws IOException {
+    URL url = new URL(downloadUrl);
+    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+    connection.setRequestMethod("GET");
+
+    if(!appToken.isEmpty()) {
+      connection.setRequestProperty(StallionApiConstants.STALLION_APP_TOKEN_KEY, appToken);
+    }
+    if(!sdkToken.isEmpty()) {
+      connection.setRequestProperty(StallionApiConstants.STALLION_SDK_TOKEN_KEY, sdkToken);
+    }
+
+    connection.setDoInput(true);
+    connection.connect();
+    return connection;
+  }
+
+  private static void validateAndUnzip(
+    File downloadedZip,
+    String destDirectory,
+    StallionDownloadCallback callback
+  ) {
+    try {
+      if (!isValidZip(downloadedZip)) {
+        callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, "Invalid ZIP file");
+        return;
+      }
+
+      StallionFileManager.unzipFile(downloadedZip.getAbsolutePath(), destDirectory);
+
+      File otaBundle = new File(destDirectory + StallionApiConstants.UNZIP_FOLDER_NAME + StallionApiConstants.ANDROID_BUNDLE_FILE_NAME);
+      if (otaBundle.exists()) {
+        callback.onSuccess(StallionApiConstants.DOWNLOAD_SUCCESS_MESSAGE);
+      } else {
+        callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, StallionApiConstants.CORRUPTED_FILE_ERROR);
+      }
+    } catch (Exception e) {
+      String filesystemError = e.getMessage();
+      callback.onReject(StallionApiConstants.DOWNLOAD_ERROR_PREFIX, StallionApiConstants.DOWNLOAD_FILESYSTEM_ERROR_MESSAGE + filesystemError);
+    } finally {
+      StallionFileManager.deleteFileOrFolderSilently(downloadedZip);
+    }
+  }
+
+  private static boolean isValidZip(File file) throws IOException {
+    try (FileInputStream fis = new FileInputStream(file)) {
+      byte[] header = new byte[4];
+      if (fis.read(header) != 4) {
+        return false;
+      }
+      return ByteBuffer.wrap(header).getInt() == 0x504b0304;
+    }
+  }
+}

package/android/src/main/java/com/stallion/networkmanager/StallionStageManager.java

@@ -0,0 +1,77 @@
+package com.stallion.networkmanager;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.stallion.events.StallionEventConstants;
+import com.stallion.events.StallionEventManager;
+import com.stallion.storage.StallionConfigConstants;
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.storage.StallionStateManager;
+
+import org.json.JSONObject;
+
+public class StallionStageManager {
+  public static void downloadStageBundle(ReadableMap bundleInfo, Promise promise) {
+    StallionStateManager stallionStateManager = StallionStateManager.getInstance();
+    String receivedDownloadUrl = bundleInfo.getString("url");
+    String receivedHash = bundleInfo.getString("hash");
+    if(
+      receivedDownloadUrl != null
+        && !receivedDownloadUrl.isEmpty()
+        && receivedHash != null
+        && !receivedHash.isEmpty()
+    ) {
+      String downloadPath = stallionStateManager.getStallionConfig().getFilesDirectory()
+        + StallionConfigConstants.STAGE_DIRECTORY
+        + StallionConfigConstants.TEMP_FOLDER_SLOT;
+
+      StallionFileDownloader.downloadBundle(
+        receivedDownloadUrl,
+        downloadPath,
+        new StallionDownloadCallback() {
+          @Override
+          public void onReject(String prefix, String error) {
+            promise.reject(prefix, error);
+          }
+
+          @Override
+          public void onSuccess(String successPayload) {
+            stallionStateManager.stallionMeta.setCurrentStageSlot(StallionMetaConstants.SlotStates.NEW_SLOT);
+            stallionStateManager.stallionMeta.setStageTempHash(receivedHash);
+            stallionStateManager.syncStallionMeta();
+            emitDownloadSuccessStage(receivedHash);
+            promise.resolve(successPayload);
+          }
+
+          @Override
+          public void onProgress(double downloadFraction) {
+            emitDownloadProgressStage(receivedHash, downloadFraction);
+          }
+        }
+      );
+    }
+  }
+
+  private static void emitDownloadSuccessStage(String releaseHash) {
+    JSONObject successPayload = new JSONObject();
+    try {
+      successPayload.put("releaseHash", releaseHash);
+    } catch (Exception ignored) { }
+    StallionEventManager.getInstance().sendEventWithoutCaching(
+      StallionEventConstants.NativeStageEventTypes.DOWNLOAD_COMPLETE_STAGE.toString(),
+      successPayload
+    );
+  }
+
+  private static void emitDownloadProgressStage(String releaseHash, double newProgress) {
+    JSONObject successPayload = new JSONObject();
+    try {
+      successPayload.put("releaseHash", releaseHash);
+      successPayload.put("progress", String.valueOf(newProgress));
+    } catch (Exception ignored) { }
+    StallionEventManager.getInstance().sendEventWithoutCaching(
+      StallionEventConstants.NativeStageEventTypes.DOWNLOAD_PROGRESS_STAGE.toString(),
+      successPayload
+    );
+  }
+}