@appsonair.ir/react-native 1.0.10 → 1.0.11

package/android/src/main/java/com/otaupdater/OTAApkInstallHelper.kt

@@ -5,47 +5,35 @@ import android.content.Intent
 import android.net.Uri
 import android.os.Build
 import android.provider.Settings
+import android.util.Log
 import androidx.core.content.FileProvider
 import com.facebook.react.bridge.ReactApplicationContext
+import java.io.BufferedInputStream
 import java.io.File
+import java.io.FileOutputStream
+import java.util.zip.ZipFile
 
 object OTAApkInstallHelper {
+  private const val TAG = "OTAApkInstall"
   private const val MIN_APK_BYTES = 1024L * 100
 
   /**
    * @return "started" when the system install screen opens, "permission_required" when settings were opened
    */
   fun install(reactContext: ReactApplicationContext, path: String): String {
-    val file = File(normalizePath(path))
-    if (!file.exists() || file.length() < MIN_APK_BYTES) {
-      throw IllegalArgumentException("APK file is missing or invalid: ${file.absolutePath}")
-    }
-
-    if (file.name.endsWith(".zip", ignoreCase = true)) {
-      throw IllegalArgumentException(
-        "Downloaded zip was not extracted to an APK before install: ${file.name}",
-      )
-    }
-
-    val archiveInfo =
-      reactContext.packageManager.getPackageArchiveInfo(
-        file.absolutePath,
-        0,
-      )
-    if (archiveInfo == null) {
-      throw IllegalArgumentException(
-        "Wrong package: file is not a valid Android APK (${file.name})",
-      )
-    }
+    val prepared = prepareInstallableApk(File(normalizePath(path)))
+    return installPrepared(reactContext, prepared)
+  }
 
+  fun installPrepared(reactContext: ReactApplicationContext, prepared: File): String {
     if (needsInstallPermission(reactContext) &&
       !reactContext.packageManager.canRequestPackageInstalls()) {
-      OTAUpdaterStorage.setPendingApkPath(reactContext, file.absolutePath)
+      OTAUpdaterStorage.setPendingApkPath(reactContext, prepared.absolutePath)
       openUnknownSourcesSettings(reactContext)
       return "permission_required"
     }
 
-    launchInstallIntent(reactContext, file)
+    launchInstallIntent(reactContext, prepared)
     OTAUpdaterStorage.clearPendingApkPath(reactContext)
     return "started"
   }
@@ -59,14 +47,129 @@ object OTAApkInstallHelper {
       return
     }
 
-    val file = File(path)
-    if (!file.exists() || file.length() < MIN_APK_BYTES) {
+    try {
+      val prepared = prepareInstallableApk(File(path))
+      launchInstallIntent(reactContext, prepared)
+      OTAUpdaterStorage.clearPendingApkPath(reactContext)
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to resume APK install", e)
       OTAUpdaterStorage.clearPendingApkPath(reactContext)
-      return
     }
+  }
 
-    launchInstallIntent(reactContext, file)
-    OTAUpdaterStorage.clearPendingApkPath(reactContext)
+  /**
+   * Ensures [file] is a real APK (has AndroidManifest.xml).
+   * If it is an outer zip that contains an .apk entry, extracts that APK first.
+   */
+  fun prepareInstallableApk(file: File): File {
+    if (!file.exists() || file.length() < MIN_APK_BYTES) {
+      throw IllegalArgumentException("APK file is missing or invalid: ${file.absolutePath}")
+    }
+
+    if (isAndroidApk(file)) {
+      return file
+    }
+
+    val unwrapped = unwrapApkFromZip(file)
+    if (unwrapped != null && isAndroidApk(unwrapped)) {
+      Log.i(TAG, "Unwrapped nested APK from zip: ${unwrapped.absolutePath}")
+      return unwrapped
+    }
+
+    throw IllegalArgumentException(
+      "Wrong package: file is not a valid Android APK (${file.name}). " +
+        "Expected an APK or a zip that contains one.",
+    )
+  }
+
+  fun isAndroidApk(file: File): Boolean = hasAndroidManifest(file)
+
+  private fun hasAndroidManifest(file: File): Boolean {
+    return try {
+      ZipFile(file).use { zip ->
+        val entries = zip.entries()
+        while (entries.hasMoreElements()) {
+          val name = entries.nextElement().name.replace('\\', '/').lowercase()
+          if (name == "androidmanifest.xml" || name.endsWith("/androidmanifest.xml")) {
+            return true
+          }
+        }
+        false
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "Not a readable zip/apk: ${file.absolutePath}", e)
+      false
+    }
+  }
+
+  private fun unwrapApkFromZip(zipFile: File): File? {
+    return try {
+      ZipFile(zipFile).use { zip ->
+        val apkEntries = mutableListOf<java.util.zip.ZipEntry>()
+        val entries = zip.entries()
+        while (entries.hasMoreElements()) {
+          val entry = entries.nextElement()
+          if (entry.isDirectory) continue
+          val name = entry.name.replace('\\', '/')
+          val base = name.substringAfterLast('/')
+          if (
+            name.split('/').contains("__MACOSX") ||
+            base.startsWith("._") ||
+            base == ".DS_Store"
+          ) {
+            continue
+          }
+          if (base.endsWith(".apk", ignoreCase = true)) {
+            apkEntries.add(entry)
+          }
+        }
+
+        if (apkEntries.isEmpty()) {
+          return null
+        }
+
+        val entry =
+          apkEntries.maxByOrNull { scoreApkEntry(it.name) }
+            ?: return null
+
+        val out =
+          File(
+            zipFile.parentFile,
+            "${zipFile.nameWithoutExtension}-unwrapped.apk",
+          )
+        if (out.exists()) {
+          out.delete()
+        }
+
+        zip.getInputStream(entry).use { input ->
+          BufferedInputStream(input).use { buffered ->
+            FileOutputStream(out).use { output ->
+              buffered.copyTo(output)
+            }
+          }
+        }
+
+        if (out.length() < MIN_APK_BYTES) {
+          out.delete()
+          return null
+        }
+
+        out
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to unwrap APK from ${zipFile.absolutePath}", e)
+      null
+    }
+  }
+
+  private fun scoreApkEntry(name: String): Int {
+    val lower = name.lowercase()
+    return when {
+      lower.contains("arm64-v8a") || lower.contains("arm64") || lower.contains("-v8a") -> 3
+      lower.contains("armeabi-v7a") || lower.contains("armeabi") || lower.contains("-v7a") -> 2
+      lower.contains("universal") -> 1
+      else -> 0
+    }
   }
 
   private fun needsInstallPermission(context: Context): Boolean =

package/android/src/main/java/com/otaupdater/OTAUpdaterModule.kt

@@ -108,14 +108,33 @@ class OTAUpdaterModule(private val reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun installApk(path: String, promise: Promise) {
-    UiThreadUtil.runOnUiThread {
+    Thread {
       try {
-        val result = OTAApkInstallHelper.install(reactContext, path)
-        promise.resolve(result)
+        val prepared = OTAApkInstallHelper.prepareInstallableApk(File(path.removePrefix("file://")))
+        UiThreadUtil.runOnUiThread {
+          try {
+            val result = OTAApkInstallHelper.installPrepared(reactContext, prepared)
+            promise.resolve(result)
+          } catch (e: Exception) {
+            promise.reject("EINSTALL", e.message, e)
+          }
+        }
       } catch (e: Exception) {
         promise.reject("EINSTALL", e.message, e)
       }
-    }
+    }.start()
+  }
+
+  @ReactMethod
+  fun isAndroidApkPackage(path: String, promise: Promise) {
+    Thread {
+      try {
+        val file = File(path.removePrefix("file://"))
+        promise.resolve(OTAApkInstallHelper.isAndroidApk(file))
+      } catch (e: Exception) {
+        promise.reject("EAPK", e.message, e)
+      }
+    }.start()
   }
 
   @ReactMethod

package/lib/sync.js

@@ -427,12 +427,27 @@ async function isZipArchive(filePath) {
     }
 }
 async function shouldExtractApkZip(downloadedPath, packageFormat) {
-    // APK files are themselves zip archives (PK magic). Only unzip when the
-    // server said this package is a zip *of* an APK, or the download is named .zip.
     if (packageFormat === 'zip') {
         return true;
     }
-    return downloadedPath.toLowerCase().endsWith('.zip');
+    if (downloadedPath.toLowerCase().endsWith('.zip')) {
+        return true;
+    }
+    // Format mismatch: zip-of-apk was saved as `.apk`. Real APKs are also zip
+    // containers, so only extract when AndroidManifest.xml is missing.
+    if (!(await isZipArchive(downloadedPath))) {
+        return false;
+    }
+    if (OTAUpdaterNative?.isAndroidApkPackage) {
+        try {
+            const isApk = await OTAUpdaterNative.isAndroidApkPackage(downloadedPath);
+            return !isApk;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
 }
 async function shouldExtractZipPackage(downloadedPath, packageFormat) {
     if (packageFormat === 'zip') {
@@ -580,16 +595,25 @@ async function extractApkUpdate(label, zipPath, deviceAbi) {
     if (!extractedApk.toLowerCase().endsWith('.apk')) {
         throw new Error('Zip did not contain a valid APK');
     }
+    const extractedStat = await ReactNativeBlobUtil.fs.stat(extractedApk);
+    if (!extractedStat || extractedStat.size < 1024 * 100) {
+        throw new Error(`Extracted APK is too small (${extractedStat?.size ?? 0} bytes)`);
+    }
     // Never hand the zip (or a nested extract path) to the installer.
     if (extractedApk !== finalApkPath) {
         const finalExists = await ReactNativeBlobUtil.fs.exists(finalApkPath);
         if (finalExists) {
             await ReactNativeBlobUtil.fs.unlink(finalApkPath);
         }
-        await ReactNativeBlobUtil.fs.cp(extractedApk, finalApkPath);
+        try {
+            await ReactNativeBlobUtil.fs.mv(extractedApk, finalApkPath);
+        }
+        catch {
+            await ReactNativeBlobUtil.fs.cp(extractedApk, finalApkPath);
+        }
     }
     const zipExists = await ReactNativeBlobUtil.fs.exists(zipPath);
-    if (zipExists) {
+    if (zipExists && zipPath !== finalApkPath) {
         await ReactNativeBlobUtil.fs.unlink(zipPath);
     }
     // Drop extract clutter; keep only the installable APK.
@@ -598,6 +622,10 @@ async function extractApkUpdate(label, zipPath, deviceAbi) {
     if (!apkExists) {
         throw new Error('Failed to prepare APK for install');
     }
+    const finalStat = await ReactNativeBlobUtil.fs.stat(finalApkPath);
+    if (!finalStat || finalStat.size < 1024 * 100) {
+        throw new Error(`Prepared APK is too small (${finalStat?.size ?? 0} bytes)`);
+    }
     return finalApkPath;
 }
 function getBundleDirectory() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsonair.ir/react-native",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "React Native client SDK for self-hosted OTA updates",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",