@hot-updater/react-native 0.0.4 → 0.1.0

package/HotUpdater.podspec

@@ -17,6 +17,8 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm}"
   s.public_header_files = ['ios/HotUpdater/HotUpdater.h']
 
+  s.dependency "SSZipArchive", "~> 2.2.2"
+
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
   if respond_to?(:install_modules_dependencies, true)

package/README.md

@@ -1,7 +1,7 @@
 # hot-updater (WIP)
 React Native OTA solution for internal infrastructure
 
-## Usage
+## IOS Usage
 * as-is
 ```objective-c
 // filename: ios/MyApp/AppDelegate.mm
@@ -33,4 +33,64 @@ React Native OTA solution for internal infrastructure
 }
 
 // ...
-```
+```
+
+## Android Usage
+```kotlin
+package com.hotupdaterexample
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.soloader.SoLoader
+import com.hotupdater.HotUpdater
+
+class MainApplication : Application(), ReactApplication {
+
+  override val reactNativeHost: ReactNativeHost =
+      object : DefaultReactNativeHost(this) {
+        override fun getPackages(): List<ReactPackage> =
+            PackageList(this).packages.apply {
+              // Packages that cannot be autolinked yet can be added manually here, for example:
+              // add(MyReactNativePackage())
+            }
+
+        override fun getJSMainModuleName(): String = "index"
+
+        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+        override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+
+        override fun getJSBundleFile(): String? {
+          // This field
+          return HotUpdater.getJSBundleFile() ?: super.getJSBundleFile()
+        }
+      }
+
+  override val reactHost: ReactHost
+    get() = getDefaultReactHost(applicationContext, reactNativeHost)
+
+  override fun onCreate() {
+    super.onCreate()
+    SoLoader.init(this, false)
+    // This field
+    HotUpdater.init(applicationContext, reactNativeHost)
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      // If you opted-in for the New Architecture, we load the native entry point for this app.
+      load()
+    }
+  }
+}
+```
+
+## Android Debug
+```sh
+> adb logcat -s HotUpdater
+```

package/android/build.gradle

@@ -0,0 +1,120 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["HotUpdater_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["HotUpdater_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["HotUpdater_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.hotupdater"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          "src/newarch",
+          // This is needed to build Kotlin project with NewArch enabled
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+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:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "HotUpdater"
+    codegenJavaPackageName = "com.hotupdater"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+HotUpdater_kotlinVersion=1.7.0
+HotUpdater_minSdkVersion=21
+HotUpdater_targetSdkVersion=31
+HotUpdater_compileSdkVersion=31
+HotUpdater_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.hotupdater">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/hotupdater/HotUpdater.kt

@@ -0,0 +1,290 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.bridge.LifecycleEventListener
+import java.io.File
+import java.lang.reflect.Field
+import java.net.URL
+import java.util.zip.ZipFile
+
+class HotUpdater internal constructor(context: Context, reactNativeHost: ReactNativeHost) {
+    private val mContext: Context = context
+    private val mReactNativeHost: ReactNativeHost = reactNativeHost
+
+    companion object {
+        private var mCurrentInstance: HotUpdater? = null
+
+        fun init(context: Context, reactNativeHost: ReactNativeHost): HotUpdater {
+            Log.d("HotUpdater", "Initializing HotUpdater")
+
+            return mCurrentInstance
+                    ?: synchronized(this) {
+                        mCurrentInstance
+                                ?: HotUpdater(context, reactNativeHost).also {
+                                    mCurrentInstance = it
+                                }
+                    }
+        }
+
+        fun getAppVersion(): String? {
+            return mCurrentInstance?.getAppVersion()
+        }
+
+        fun initializeOnAppUpdate() {
+            mCurrentInstance?.initializeOnAppUpdate()
+        }
+
+        fun reload() {
+            mCurrentInstance?.reload()
+        }
+
+        fun getJSBundleFile(): String? {
+            Log.d("HotUpdater", "Getting JS bundle file ${mCurrentInstance?.getBundleURL()}")
+            return mCurrentInstance?.getBundleURL()
+        }
+
+        fun getBundleVersion(): Double? {
+            return mCurrentInstance?.getBundleVersion()
+        }
+
+        fun updateBundle(prefix: String, url: String?): Boolean? {
+            return mCurrentInstance?.updateBundle(prefix, url)
+        }
+    }
+
+    private val documentsDir: String
+        get() = mContext.getExternalFilesDir(null)?.absolutePath ?: mContext.filesDir.absolutePath
+
+    private fun convertFileSystemPathFromBasePath(basePath: String): String {
+        val separator = if (basePath.startsWith("/")) "" else "/"
+        return "$documentsDir$separator$basePath"
+    }
+
+    private fun stripPrefixFromPath(prefix: String, path: String): String {
+        return if (path.startsWith("/$prefix/")) {
+            path.replaceFirst("/$prefix/", "")
+        } else {
+            path
+        }
+    }
+
+    private fun loadBundleLegacy() {
+        val currentActivity: Activity? =
+                mReactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+        if (currentActivity == null) {
+            return
+        }
+
+        currentActivity.runOnUiThread { currentActivity.recreate() }
+    }
+    private var mLifecycleEventListener: LifecycleEventListener? = null
+
+    private fun clearLifecycleEventListener() {
+        if (mLifecycleEventListener != null) {
+            mReactNativeHost.reactInstanceManager.currentReactContext?.removeLifecycleEventListener(
+                    mLifecycleEventListener
+            )
+            mLifecycleEventListener = null
+        }
+    }
+
+    private fun setJSBundle(instanceManager: ReactInstanceManager, latestJSBundleFile: String?) {
+
+        try {
+            var latestJSBundleLoader: JSBundleLoader? = null
+
+            if (latestJSBundleFile != null && latestJSBundleFile.lowercase().startsWith("assets://")
+            ) {
+                latestJSBundleLoader =
+                        JSBundleLoader.createAssetLoader(
+                                instanceManager.currentReactContext,
+                                latestJSBundleFile,
+                                false
+                        )
+            } else if (latestJSBundleFile != null) {
+                latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile)
+            }
+            val bundleLoaderField: Field =
+                    instanceManager::class.java.getDeclaredField("mBundleLoader")
+            bundleLoaderField.isAccessible = true
+
+            if (latestJSBundleLoader != null) {
+                bundleLoaderField.set(instanceManager, latestJSBundleLoader)
+            } else {
+                bundleLoaderField.set(instanceManager, null)
+            }
+        } catch (e: Exception) {
+            throw IllegalAccessException("Could not setJSBundle")
+        }
+    }
+
+    fun initializeOnAppUpdate() {
+        val sharedPreferences =
+                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+
+        val currentVersion = getAppVersion()
+        val savedVersion = sharedPreferences.getString("HotUpdaterAppVersion", null)
+
+        if (currentVersion != savedVersion) {
+            val editor = sharedPreferences.edit()
+            editor.remove("HotUpdaterBundleURL")
+            editor.remove("HotUpdaterBundleVersion")
+            editor.putString("HotUpdaterAppVersion", currentVersion)
+            editor.apply()
+        }
+    }
+
+    fun reload() {
+        Log.d("HotUpdater", "HotUpdater requested a reload ${getBundleURL()}")
+
+        setJSBundle(mReactNativeHost.reactInstanceManager, getBundleURL())
+
+        clearLifecycleEventListener()
+        try {
+            Handler(Looper.getMainLooper()).post {
+                try {
+                    mReactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+                } catch (t: Throwable) {
+                    loadBundleLegacy()
+                }
+            }
+        } catch (t: Throwable) {
+            loadBundleLegacy()
+        }
+    }
+
+    fun getAppVersion(): String {
+        val packageInfo = mContext.packageManager.getPackageInfo(mContext.packageName, 0)
+        return packageInfo.versionName
+    }
+
+    fun getBundleURL(): String {
+        val sharedPreferences =
+                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+        val urlString = sharedPreferences.getString("HotUpdaterBundleURL", null)
+        if (urlString.isNullOrEmpty()) {
+            return "assets://index.android.bundle"
+        }
+
+        return urlString
+    }
+
+    private fun setBundleURL(bundleURL: String?) {
+        val sharedPreferences =
+                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+        with(sharedPreferences.edit()) {
+            putString("HotUpdaterBundleURL", bundleURL)
+            apply()
+        }
+    }
+    private fun setBundleVersion(bundleVersion: String?) {
+        val sharedPreferences =
+                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+        with(sharedPreferences.edit()) {
+            putString("HotUpdaterBundleVersion", bundleVersion)
+            apply()
+        }
+    }
+
+    fun getBundleVersion(): Double? {
+        val sharedPreferences =
+                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+        val bundleVersion = sharedPreferences.getString("HotUpdaterBundleVersion", null)
+        Log.d("HotUpdater", "Bundle version: $bundleVersion")
+        return if (bundleVersion != null && bundleVersion.isNotEmpty()) {
+            try {
+                bundleVersion.toDouble()
+            } catch (e: Exception) {
+                -1.0
+            }
+        } else {
+            -1.0
+        }
+    }
+
+    private fun extractZipFileAtPath(filePath: String, destinationPath: String): Boolean {
+        return try {
+            ZipFile(filePath).use { zip ->
+                zip.entries().asSequence().forEach { entry ->
+                    val file = File(destinationPath, entry.name)
+                    if (entry.isDirectory) {
+                        file.mkdirs()
+                    } else {
+                        file.parentFile?.mkdirs()
+                        zip.getInputStream(entry).use { input ->
+                            file.outputStream().use { output -> input.copyTo(output) }
+                        }
+                    }
+                }
+            }
+            true
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to unzip file: ${e.message}")
+            false
+        }
+    }
+
+    fun updateBundle(prefix: String, url: String?): Boolean {
+        if (url == null) {
+            setBundleURL(null)
+            setBundleVersion(null)
+            return true
+        }
+
+        val downloadUrl = URL(url)
+
+        val basePath = stripPrefixFromPath(prefix, downloadUrl.path)
+        val path = convertFileSystemPathFromBasePath(basePath)
+
+        val data =
+                try {
+                    downloadUrl.readBytes()
+                } catch (e: Exception) {
+                    Log.d("HotUpdater", "Failed to download data from URL: $url")
+                    return false
+                }
+
+        val file = File(path)
+        try {
+            file.parentFile?.mkdirs()
+            file.writeBytes(data)
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to save data: ${e.message}")
+            return false
+        }
+
+        val extractedPath = file.parentFile?.path
+        if (extractedPath == null) {
+            return false
+        }
+
+        if (!extractZipFileAtPath(path, extractedPath)) {
+            Log.d("HotUpdater", "Failed to extract zip file.")
+            return false
+        }
+
+        val extractedDirectory = File(extractedPath)
+        val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle.js" }
+
+        if (indexFile != null) {
+            val bundlePath = indexFile.path
+            Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
+            setBundleURL(bundlePath)
+        } else {
+            Log.d("HotUpdater", "index.android.bundle.js not found.")
+            return false
+        }
+
+        setBundleVersion(prefix)
+        Log.d("HotUpdater", "Downloaded and extracted file successfully.")
+
+        return true
+    }
+}

package/android/src/main/java/com/hotupdater/HotUpdaterModule.kt

@@ -0,0 +1,45 @@
+package com.hotupdater
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+
+class HotUpdaterModule internal constructor(context: ReactApplicationContext) :
+    HotUpdaterSpec(context) {
+
+  private val mReactApplicationContext: ReactApplicationContext = context
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  override fun initializeOnAppUpdate() {
+    HotUpdater.initializeOnAppUpdate()
+  }
+
+  @ReactMethod
+  override fun reload() {
+    HotUpdater.reload()
+  }
+
+  @ReactMethod
+  override fun getAppVersion(callback: Callback) {
+    callback.invoke(HotUpdater.getAppVersion())
+  }
+
+  @ReactMethod
+  override fun getBundleVersion(callback: Callback) {
+    callback.invoke(HotUpdater.getBundleVersion())
+  }
+
+  @ReactMethod
+  override fun updateBundle(prefix: String, url: String?, callback: Callback) {
+    val result = HotUpdater.updateBundle(prefix, url)
+    callback.invoke(result)
+  }
+
+  companion object {
+    const val NAME = "HotUpdater"
+  }
+}

package/android/src/main/java/com/hotupdater/HotUpdaterPackage.kt

@@ -0,0 +1,36 @@
+package com.hotupdater
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class HotUpdaterPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == HotUpdaterModule.NAME) {
+      HotUpdaterModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      moduleInfos[HotUpdaterModule.NAME] =
+          ReactModuleInfo(
+              HotUpdaterModule.NAME,
+              HotUpdaterModule.NAME,
+              false, // canOverrideExistingModule
+              false, // needsEagerInit
+              true, // hasConstants
+              false, // isCxxModule
+              isTurboModule // isTurboModule
+          )
+      moduleInfos
+    }
+  }
+}

package/android/src/newarch/HotUpdaterSpec.kt

@@ -0,0 +1,6 @@
+package com.hotupdater
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class HotUpdaterSpec internal constructor(context: ReactApplicationContext) :
+        NativeHotUpdaterSpec(context) {}

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -0,0 +1,15 @@
+package com.hotupdater
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+abstract class HotUpdaterSpec internal constructor(context: ReactApplicationContext) :
+    ReactContextBaseJavaModule(context) {
+
+  abstract fun updateBundle(prefix: String, url: String?, callback: Callback)
+  abstract fun reload()
+  abstract fun initializeOnAppUpdate()
+  abstract fun getAppVersion(callback: Callback)
+  abstract fun getBundleVersion(callback: Callback)
+}