react-native-stallion 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# react-native-stallion
+Stallion is the ultimate testing framework for React Native apps !
+It is a simplified build sharing and testing system that skips all the tedious hastle of generating a new new APK or IPA build everytime you make react native code changes.
+With stallion a developer can directly publish a react native build to Stallion servers and any tester can simply download updates through the Stallion app SDK without re installing the app.
+
+## SDK Installation
+
+### npm
+```
+npm install --save react-native-stallion
+```
+
+### yarn
+```
+yarn add react-native-stallion
+```
+
+check complete SDK installation steps from [here](https://docs.redhorse.tech/docs/install)
+
+## Documentation
+Document contains installation steps, usage and how to disable stallion in production
+
+https://redhorse-tech.github.io/stallion-docs/
+
+## Contributing
+
+Please see the [contributing](./CONTRIBUTING.MD) file
+for an introduction to the codebase and what the various moving parts are.
+
+## Open issues
+
+Check out [open issues](https://github.com/redhorse-tech/react-native-stallion/issues) for a list of known issues, and discussions.
+
+## Code of Conduct
+
+You can find the code of conduct [here](./CODE_OF_CONDUCT.md)

package/android/build.gradle

@@ -0,0 +1,100 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Stallion_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Stallion_" + name]).toInteger()
+}
+
+def enabledOutput = new ByteArrayOutputStream()
+try {
+  exec {
+    commandLine "node", "../src/nativeScripts/getStallionEnabled.js"
+    standardOutput = enabledOutput;
+  }
+  enabledOutput = enabledOutput.toString().trim()
+} catch(Exception e) {
+  this.logger.error("Error evaluating stallion enabled script. Make sure node is installed on your system")
+  throw e;
+}
+
+def stallionEnabled = enabledOutput == "true"
+
+android {
+  sourceSets {
+     if(stallionEnabled) {
+       main.java.srcDirs = ["src/main/java"]
+     } else {
+       main.java.srcDirs = ["src/noop/java"]
+       this.logger.warn("Stallion is disabled, falling back to noop version. Check your stallion.config.js file")
+     }
+   }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Stallion"
+    codegenJavaPackageName = "com.stallion"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Stallion_kotlinVersion=1.7.0
+Stallion_minSdkVersion=21
+Stallion_targetSdkVersion=31
+Stallion_compileSdkVersion=31
+Stallion_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.stallion">
+  <application>
+    <activity
+      android:name="com.stallion.StallionDefaultErrorActivity">
+    </activity>
+  </application>
+</manifest>

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

@@ -0,0 +1,26 @@
+package com.stallion;
+
+import android.content.Context;
+
+public class Stallion {
+
+  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();
+    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;
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+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 API_BASE = "https://stallion-api.redhorse.tech/api/v1";
+  public static final String DOWNLOAD_API_PATH = "/bundle/download";
+  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 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";
+
+}
+

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

@@ -0,0 +1,27 @@
+package com.stallion;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.Button;
+import android.widget.TextView;
+
+public class StallionDefaultErrorActivity extends Activity {
+  private TextView stackTraceView;
+  private Button continueButton;
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    Log.d("StallionDefault", "StallionDefaultErrorActivity");
+    String receivedStackTrace = getIntent().getExtras().getString("stack_trace_string");
+    String stackTraceString = receivedStackTrace != null ? receivedStackTrace : "null";
+    setContentView(R.layout.stallion_default_error_activity);
+    stackTraceView = findViewById(R.id.seb_stack_trace_text_view);
+    stackTraceView.setText(stackTraceString);
+    continueButton = findViewById(R.id.seb_continue_button);
+    continueButton.setOnClickListener(view -> continueExceptionFlow());
+  }
+  private void continueExceptionFlow() {
+    StallionModule.continueExcetionFlow();
+  }
+}

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

@@ -0,0 +1,250 @@
+package com.stallion;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+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 android.app.Activity;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.Looper;
+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.io.OutputStream;
+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;
+  public static Thread.UncaughtExceptionHandler _androidUncaughtExceptionHandler;
+  public static Thread _exceptionThread;
+  public static Throwable _exceptionThrowable;
+
+  public StallionModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.currentReactContext = reactContext;
+    this.baseDir = reactContext.getFilesDir().getAbsolutePath() + StallionConstants.STALLION_PACKAGE_PATH;
+    StallionStorage.getInstance().Initialize(reactContext);
+    this.stallionStorage = StallionStorage.getInstance();
+    _androidUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
+    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+      @Override
+      public void uncaughtException(Thread thread, Throwable throwable) {
+        _exceptionThread = thread;
+        _exceptionThrowable = throwable;
+        String stackTraceString = Log.getStackTraceString(throwable);
+        if(stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER) == StallionConstants.STALLION_SWITCH_ON) {
+          toggleStallionSwitch(false);
+          Activity currentActivity = getCurrentActivity();
+          Intent myIntent = new Intent(currentActivity, StallionDefaultErrorActivity.class);
+          myIntent.putExtra("stack_trace_string", stackTraceString);
+          currentActivity.startActivity(myIntent);
+          currentActivity.finish();
+        } else {
+          continueExcetionFlow();
+        }
+      }
+    });
+  }
+
+  public static void continueExcetionFlow() {
+    _androidUncaughtExceptionHandler.uncaughtException(_exceptionThread, _exceptionThrowable);
+  }
+
+
+  @Override
+  @NonNull
+  public String getName() {
+    return StallionConstants.MODULE_NAME;
+  }
+
+  @ReactMethod
+  public void setApiKey(String apiKey) {
+    this.stallionStorage.set(StallionConstants.API_KEY_IDENTIFIER, apiKey);
+  }
+
+  @ReactMethod
+  public void getApiKey(Callback callback) {
+    callback.invoke(
+      this.stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER)
+    );
+  }
+
+  @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 : this.stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER).equals(StallionConstants.STALLION_SWITCH_ON)
+    );
+    bundleMeta.putString(StallionConstants.ACTIVE_VERSION_IDENTIFIER, String.valueOf(activeVersion));
+    callback.invoke(bundleMeta);
+  }
+
+  @ReactMethod
+  public void toggleStallionSwitch(Boolean stallionBundleIsOn) {
+    this.stallionStorage.set(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER, stallionBundleIsOn ? StallionConstants.STALLION_SWITCH_ON : StallionConstants.STALLION_SWITCH_OFF);
+  }
+
+  private DeviceEventManagerModule.RCTDeviceEventEmitter getEventEmitter() {
+    if(this.eventEmitter == null) {
+      this.eventEmitter = this.currentReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    }
+    return this.eventEmitter;
+  }
+
+  @ReactMethod
+  public void downloadPackage(ReadableMap bundleInfo, Promise promise) {
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    Handler handler = new Handler(Looper.getMainLooper());
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        String receivedBucketId = bundleInfo.getString("bucketId");
+        String receivedProjectId = bundleInfo.getString("projectId");
+        Integer receivedVersion = bundleInfo.getInt("version");
+        String platformValue = "android";
+        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(StallionConstants.API_BASE + StallionConstants.DOWNLOAD_API_PATH);
+          connection = (HttpURLConnection) url.openConnection();
+          connection.setRequestMethod( "POST" );
+          connection.setRequestProperty("x-access-token", stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER));
+          connection.setRequestProperty("Content-Type", "application/json");
+
+          String jsonInputString = String.format("{\"bucketId\":\"%s\",\"projectId\":\"%s\",\"version\":%d,\"platform\":\"%s\"}", receivedBucketId, receivedProjectId, receivedVersion, platformValue);
+
+          connection.setDoOutput(true);
+          connection.setDoInput(true);
+          OutputStream os = connection.getOutputStream();
+          os.write(jsonInputString.getBytes("UTF-8"));
+          os.close();
+
+          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 progressEventThrehold = 0.02;
+          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 > progressEventThrehold) {
+              prevDownloadFraction = currentDownloadFraction;
+              getReactApplicationContext().runOnUiQueueThread(new Runnable() {
+                @Override
+                public void run() {
+                  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) {
+          Log.d("DOWNLOAD_ERROR", e.toString());
+          promise.reject(e.toString());
+        } 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(e.toString());
+          }
+        }
+
+        if (!isZip) {
+          promise.reject("Not a zip file");
+          return;
+        }
+
+        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("Success");
+        } catch (Exception e) {
+          promise.reject(e.toString());
+        } finally {
+          StallionZip.deleteFileOrFolderSilently(downloadedZip);
+          return;
+        }
+      }
+    });
+  }
+}

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

@@ -0,0 +1,29 @@
+package com.stallion;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class StallionPackage implements ReactPackage {
+
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new StallionModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

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

@@ -0,0 +1,54 @@
+package com.stallion;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+
+public class StallionStorage {
+  private static StallionStorage mInstance;
+  private Context mContext;
+
+  private SharedPreferences sharedPreference;
+
+  public static StallionStorage getInstance(){
+    if (mInstance == null) mInstance = new StallionStorage();
+    return mInstance;
+  }
+
+  public void Initialize(Context context){
+    mContext = context;
+    sharedPreference = PreferenceManager.getDefaultSharedPreferences(mContext);
+  }
+
+  public void set(String key, String value) {
+    SharedPreferences.Editor editor = sharedPreference.edit();
+    editor.putString(key, value);
+    editor.commit();
+  }
+
+  public void setInt(String key, Integer value) {
+    SharedPreferences.Editor editor = sharedPreference.edit();
+    editor.putInt(key, value);
+    editor.commit();
+  }
+
+  public Integer getInt(String key) {
+    return sharedPreference.getInt(key, -1);
+  }
+
+  public String get(String key) {
+    return sharedPreference.getString(key, null);
+  }
+
+  public void delete(String key, Boolean deleteAll) {
+    SharedPreferences.Editor editor = sharedPreference.edit();
+    if(deleteAll == true){
+      editor.clear();
+      return;
+    } else {
+      editor.remove(key);
+    }
+  }
+}
+
+