@appsonair.ir/react-native 1.0.12 → 1.0.13

package/android/src/main/AndroidManifest.xml

@@ -9,6 +9,14 @@
       android:process=":ota_restart"
       android:theme="@android:style/Theme.Translucent.NoTitleBar" />
 
+    <receiver
+      android:name=".OTAApkInstallReceiver"
+      android:exported="false">
+      <intent-filter>
+        <action android:name="com.otaupdater.APK_INSTALL_STATUS" />
+      </intent-filter>
+    </receiver>
+
     <provider
       android:name=".OTAFirebaseInitProvider"
       android:authorities="${applicationId}.otaupdater.firebaseinit"

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

@@ -1,31 +1,40 @@
 package com.otaupdater
 
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageInfo
+import android.content.pm.PackageInstaller
+import android.content.pm.PackageManager
 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.FileInputStream
 import java.io.FileOutputStream
+import java.security.MessageDigest
 import java.util.zip.ZipFile
 
 object OTAApkInstallHelper {
   private const val TAG = "OTAApkInstall"
   private const val MIN_APK_BYTES = 1024L * 100
+  const val ACTION_INSTALL_STATUS = "com.otaupdater.APK_INSTALL_STATUS"
 
   /**
    * @return "started" when the system install screen opens, "permission_required" when settings were opened
    */
   fun install(reactContext: ReactApplicationContext, path: String): String {
-    val prepared = prepareInstallableApk(File(normalizePath(path)))
+    val prepared = prepareInstallableApk(reactContext, File(normalizePath(path)))
     return installPrepared(reactContext, prepared)
   }
 
   fun installPrepared(reactContext: ReactApplicationContext, prepared: File): String {
+    validateApkForInstall(reactContext, prepared)
+
     if (needsInstallPermission(reactContext) &&
       !reactContext.packageManager.canRequestPackageInstalls()) {
       OTAUpdaterStorage.setPendingApkPath(reactContext, prepared.absolutePath)
@@ -33,7 +42,7 @@ object OTAApkInstallHelper {
       return "permission_required"
     }
 
-    launchInstallIntent(reactContext, prepared)
+    commitPackageInstallerSession(reactContext, prepared)
     OTAUpdaterStorage.clearPendingApkPath(reactContext)
     return "started"
   }
@@ -48,8 +57,9 @@ object OTAApkInstallHelper {
     }
 
     try {
-      val prepared = prepareInstallableApk(File(path))
-      launchInstallIntent(reactContext, prepared)
+      val prepared = prepareInstallableApk(reactContext, File(path))
+      validateApkForInstall(reactContext, prepared)
+      commitPackageInstallerSession(reactContext, prepared)
       OTAUpdaterStorage.clearPendingApkPath(reactContext)
     } catch (e: Exception) {
       Log.e(TAG, "Failed to resume APK install", e)
@@ -61,6 +71,30 @@ object OTAApkInstallHelper {
    * 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(reactContext: ReactApplicationContext, file: File): File {
+    if (!file.exists() || file.length() < MIN_APK_BYTES) {
+      throw IllegalArgumentException("APK file is missing or invalid: ${file.absolutePath}")
+    }
+
+    val apkFile =
+      if (isAndroidApk(file)) {
+        file
+      } else {
+        val unwrapped = unwrapApkFromZip(file)
+        if (unwrapped != null && isAndroidApk(unwrapped)) {
+          Log.i(TAG, "Unwrapped nested APK from zip: ${unwrapped.absolutePath}")
+          unwrapped
+        } else {
+          throw IllegalArgumentException(
+            "Wrong package: file is not a valid Android APK (${file.name}). " +
+              "Expected an APK or a zip that contains one.",
+          )
+        }
+      }
+
+    return copyToInstallCache(reactContext, apkFile)
+  }
+
   fun prepareInstallableApk(file: File): File {
     if (!file.exists() || file.length() < MIN_APK_BYTES) {
       throw IllegalArgumentException("APK file is missing or invalid: ${file.absolutePath}")
@@ -84,6 +118,136 @@ object OTAApkInstallHelper {
 
   fun isAndroidApk(file: File): Boolean = hasAndroidManifest(file)
 
+  /**
+   * Catch the usual "App not installed" causes before the system UI fails opaquely:
+   * versionCode downgrade / same build, and signing-key mismatch.
+   */
+  fun validateApkForInstall(context: Context, apkFile: File) {
+    val pm = context.packageManager
+    val archive =
+      readArchivePackageInfo(pm, apkFile)
+        ?: throw IllegalArgumentException(
+          "Wrong package: Android cannot parse this APK (${apkFile.name})",
+        )
+
+    val packageName =
+      archive.packageName
+        ?: throw IllegalArgumentException("Wrong package: APK has no package name")
+
+    val newCode = packageLongVersionCode(archive)
+
+    val installed =
+      try {
+        readInstalledPackageInfo(pm, packageName)
+      } catch (_: PackageManager.NameNotFoundException) {
+        Log.i(TAG, "APK $packageName is a fresh install (versionCode=$newCode)")
+        return
+      }
+
+    val oldCode = packageLongVersionCode(installed)
+    if (newCode < oldCode) {
+      throw IllegalArgumentException(
+        "Cannot install: APK versionCode $newCode is older than installed $oldCode. " +
+          "Upload an APK with a higher versionCode.",
+      )
+    }
+    if (newCode == oldCode) {
+      throw IllegalArgumentException(
+        "Cannot install: APK versionCode $newCode is already installed. " +
+          "Bump versionCode (build number) and upload again.",
+      )
+    }
+
+    if (!signaturesMatch(installed, archive)) {
+      throw IllegalArgumentException(
+        "Cannot install: APK is signed with a different key than the installed app. " +
+          "Use the same keystore that signed the app currently on the device.",
+      )
+    }
+
+    Log.i(
+      TAG,
+      "APK OK for update: $packageName versionCode $oldCode → $newCode (${apkFile.length()} bytes)",
+    )
+  }
+
+  private fun commitPackageInstallerSession(context: Context, apkFile: File) {
+    val installer = context.packageManager.packageInstaller
+    val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
+
+    val sessionId = installer.createSession(params)
+    val session = installer.openSession(sessionId)
+
+    try {
+      FileInputStream(apkFile).use { input ->
+        session.openWrite("package", 0, apkFile.length()).use { output ->
+          input.copyTo(output)
+          session.fsync(output)
+        }
+      }
+
+      val action = Intent(ACTION_INSTALL_STATUS).apply {
+        setPackage(context.packageName)
+      }
+      val flags =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+          PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        } else {
+          PendingIntent.FLAG_UPDATE_CURRENT
+        }
+      val pending =
+        PendingIntent.getBroadcast(context, sessionId, action, flags)
+
+      session.commit(pending.intentSender)
+      Log.i(TAG, "PackageInstaller session $sessionId committed for ${apkFile.name}")
+    } catch (e: Exception) {
+      try {
+        session.abandon()
+      } catch (_: Exception) {
+        // Ignore abandon errors.
+      }
+      throw e
+    } finally {
+      try {
+        session.close()
+      } catch (_: Exception) {
+        // Ignore close errors.
+      }
+    }
+  }
+
+  private fun copyToInstallCache(context: Context, apkFile: File): File {
+    val cacheDir = File(context.filesDir, "ota-apk-install")
+    if (!cacheDir.exists() && !cacheDir.mkdirs()) {
+      Log.w(TAG, "Could not create install cache dir; using source APK")
+      return apkFile
+    }
+
+    val dest = File(cacheDir, "update.apk")
+    if (dest.absolutePath == apkFile.absolutePath) {
+      return apkFile
+    }
+
+    try {
+      if (dest.exists()) {
+        dest.delete()
+      }
+      apkFile.inputStream().use { input ->
+        FileOutputStream(dest).use { output ->
+          input.copyTo(output)
+        }
+      }
+      if (dest.length() != apkFile.length() || !isAndroidApk(dest)) {
+        dest.delete()
+        return apkFile
+      }
+      return dest
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to copy APK to install cache; using source", e)
+      return apkFile
+    }
+  }
+
   private fun hasAndroidManifest(file: File): Boolean {
     return try {
       ZipFile(file).use { zip ->
@@ -149,6 +313,15 @@ object OTAApkInstallHelper {
           }
         }
 
+        if (entry.size > 0 && out.length() != entry.size) {
+          Log.e(
+            TAG,
+            "Unwrapped APK size mismatch: got ${out.length()}, expected ${entry.size}",
+          )
+          out.delete()
+          return null
+        }
+
         if (out.length() < MIN_APK_BYTES) {
           out.delete()
           return null
@@ -175,20 +348,6 @@ object OTAApkInstallHelper {
   private fun needsInstallPermission(context: Context): Boolean =
     Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
 
-  private fun launchInstallIntent(context: Context, file: File) {
-    val authority = "${context.packageName}.otaupdater.fileprovider"
-    val uri = FileProvider.getUriForFile(context, authority, file)
-
-    val installIntent =
-      Intent(Intent.ACTION_VIEW).apply {
-        setDataAndType(uri, "application/vnd.android.package-archive")
-        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-      }
-
-    context.startActivity(installIntent)
-  }
-
   private fun openUnknownSourcesSettings(reactContext: ReactApplicationContext) {
     val intent =
       Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
@@ -204,5 +363,125 @@ object OTAApkInstallHelper {
     }
   }
 
+  private fun readArchivePackageInfo(pm: PackageManager, apkFile: File): PackageInfo? {
+    val info =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        pm.getPackageArchiveInfo(
+          apkFile.absolutePath,
+          PackageManager.PackageInfoFlags.of(PackageManager.GET_SIGNING_CERTIFICATES.toLong()),
+        )
+      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        @Suppress("DEPRECATION")
+        pm.getPackageArchiveInfo(apkFile.absolutePath, PackageManager.GET_SIGNING_CERTIFICATES)
+      } else {
+        @Suppress("DEPRECATION")
+        pm.getPackageArchiveInfo(apkFile.absolutePath, PackageManager.GET_SIGNATURES)
+      }
+
+    info?.applicationInfo?.sourceDir = apkFile.absolutePath
+    info?.applicationInfo?.publicSourceDir = apkFile.absolutePath
+    return info
+  }
+
+  private fun readInstalledPackageInfo(pm: PackageManager, packageName: String): PackageInfo {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      pm.getPackageInfo(
+        packageName,
+        PackageManager.PackageInfoFlags.of(PackageManager.GET_SIGNING_CERTIFICATES.toLong()),
+      )
+    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      @Suppress("DEPRECATION")
+      pm.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES)
+    } else {
+      @Suppress("DEPRECATION")
+      pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES)
+    }
+  }
+
+  private fun packageLongVersionCode(info: PackageInfo): Long {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      info.longVersionCode
+    } else {
+      @Suppress("DEPRECATION")
+      info.versionCode.toLong()
+    }
+  }
+
+  private fun signaturesMatch(installed: PackageInfo, archive: PackageInfo): Boolean {
+    val installedDigests = signingDigests(installed)
+    val archiveDigests = signingDigests(archive)
+    if (installedDigests.isEmpty() || archiveDigests.isEmpty()) {
+      // Some devices omit archive signing info — don't block install on missing data.
+      Log.w(TAG, "Could not compare APK signatures; continuing install")
+      return true
+    }
+    return installedDigests.any { it in archiveDigests }
+  }
+
+  private fun signingDigests(info: PackageInfo): Set<String> {
+    val digests = linkedSetOf<String>()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      val signingInfo = info.signingInfo ?: return digests
+      val signers =
+        if (signingInfo.hasMultipleSigners()) {
+          signingInfo.apkContentsSigners
+        } else {
+          signingInfo.signingCertificateHistory
+        }
+      for (signature in signers) {
+        digests.add(sha256Hex(signature.toByteArray()))
+      }
+    } else {
+      @Suppress("DEPRECATION")
+      val signatures = info.signatures ?: return digests
+      for (signature in signatures) {
+        digests.add(sha256Hex(signature.toByteArray()))
+      }
+    }
+    return digests
+  }
+
+  private fun sha256Hex(bytes: ByteArray): String {
+    val digest = MessageDigest.getInstance("SHA-256").digest(bytes)
+    return digest.joinToString("") { "%02x".format(it) }
+  }
+
   private fun normalizePath(path: String): String = path.removePrefix("file://")
 }
+
+class OTAApkInstallReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context, intent: Intent?) {
+    if (intent == null) return
+
+    val status =
+      intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE)
+    val message = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE)
+
+    when (status) {
+      PackageInstaller.STATUS_PENDING_USER_ACTION -> {
+        val confirm =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
+          } else {
+            @Suppress("DEPRECATION")
+            intent.getParcelableExtra(Intent.EXTRA_INTENT)
+          }
+        if (confirm != null) {
+          confirm.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+          context.startActivity(confirm)
+        } else {
+          Log.e(OTAApkInstallHelper.TAG, "Install pending user action but EXTRA_INTENT missing")
+        }
+      }
+      PackageInstaller.STATUS_SUCCESS -> {
+        Log.i(OTAApkInstallHelper.TAG, "APK installed successfully")
+      }
+      else -> {
+        Log.e(
+          OTAApkInstallHelper.TAG,
+          "APK install failed status=$status message=${message ?: "unknown"}",
+        )
+      }
+    }
+  }
+}

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

@@ -110,7 +110,11 @@ class OTAUpdaterModule(private val reactContext: ReactApplicationContext) :
   fun installApk(path: String, promise: Promise) {
     Thread {
       try {
-        val prepared = OTAApkInstallHelper.prepareInstallableApk(File(path.removePrefix("file://")))
+        val prepared =
+          OTAApkInstallHelper.prepareInstallableApk(
+            reactContext,
+            File(path.removePrefix("file://")),
+          )
         UiThreadUtil.runOnUiThread {
           try {
             val result = OTAApkInstallHelper.installPrepared(reactContext, prepared)

package/lib/sync.d.ts

@@ -77,7 +77,12 @@ export declare function checkForUpdate(serverUrl: string, deploymentKey: string,
 export declare function getBundleReleaseDir(label: string): string;
 export declare function getBundleFilePath(label: string): string;
 export declare function getApkFilePath(label: string): string;
-export declare function downloadBundle(downloadUrl: string, deploymentKey: string, label: string, expectedSize?: number, onProgress?: (progress: number, received?: number, total?: number) => void, extension?: 'bundle' | 'apk', deviceAbi?: string, packageFormat?: 'bundle' | 'zip', expectedHash?: string): Promise<string>;
+export declare function downloadBundle(downloadUrl: string, deploymentKey: string, label: string, expectedSize?: number, onProgress?: (progress: number, received?: number, total?: number) => void, extension?: 'bundle' | 'apk', deviceAbi?: string, packageFormat?: 'bundle' | 'zip', expectedHash?: string, 
+/**
+ * When false, APK zip downloads are left as `.zip` for native unwrap/install.
+ * JS-side unzip has produced invalid `.apk` files on some devices.
+ */
+extractApk?: boolean): Promise<string>;
 export declare function verifyBundleHash(filePath: string, expectedHash: string): Promise<boolean>;
 type ProgressCallback = (status: SyncStatus, progress?: number) => void;
 export declare function isSyncInProgress(): boolean;

package/lib/sync.js

@@ -750,7 +750,7 @@ async function cleanupPartialDownload(path) {
  * bytesWritten !== Content-Length — including when Content-Length is wrong
  * but the full file actually landed. Recover those cases via size/hash checks.
  */
-async function tryRecoverCompletedDownload(destPath, extension, totalBytes, expectedHash, packageFormat, label, deviceAbi) {
+async function tryRecoverCompletedDownload(destPath, extension, totalBytes, expectedHash, packageFormat, label, deviceAbi, extractApk = true) {
     try {
         const ReactNativeBlobUtil = require('react-native-blob-util').default;
         const exists = await ReactNativeBlobUtil.fs.exists(destPath);
@@ -769,7 +769,9 @@ async function tryRecoverCompletedDownload(destPath, extension, totalBytes, expe
         else if (!sizeLooksComplete) {
             return null;
         }
-        if (extension === 'apk' && (await shouldExtractApkZip(destPath, packageFormat))) {
+        if (extractApk &&
+            extension === 'apk' &&
+            (await shouldExtractApkZip(destPath, packageFormat))) {
             return extractApkUpdate(label, destPath, deviceAbi);
         }
         if (extension === 'bundle' && (await shouldExtractZipPackage(destPath, packageFormat))) {
@@ -781,7 +783,12 @@ async function tryRecoverCompletedDownload(destPath, extension, totalBytes, expe
         return null;
     }
 }
-async function downloadBundle(downloadUrl, deploymentKey, label, expectedSize, onProgress, extension = 'bundle', deviceAbi, packageFormat = 'bundle', expectedHash) {
+async function downloadBundle(downloadUrl, deploymentKey, label, expectedSize, onProgress, extension = 'bundle', deviceAbi, packageFormat = 'bundle', expectedHash, 
+/**
+ * When false, APK zip downloads are left as `.zip` for native unwrap/install.
+ * JS-side unzip has produced invalid `.apk` files on some devices.
+ */
+extractApk = true) {
     const ReactNativeBlobUtil = require('react-native-blob-util').default;
     const isZipBundle = extension === 'bundle' && packageFormat === 'zip';
     const isApkZip = extension === 'apk' && packageFormat === 'zip';
@@ -876,7 +883,9 @@ async function downloadBundle(downloadUrl, deploymentKey, label, expectedSize, o
                     throw new Error('Wrong package: hash verification failed');
                 }
             }
-            if (extension === 'apk' && (await shouldExtractApkZip(destPath, packageFormat))) {
+            if (extractApk &&
+                extension === 'apk' &&
+                (await shouldExtractApkZip(destPath, packageFormat))) {
                 return extractApkUpdate(label, destPath, deviceAbi);
             }
             if (extension === 'bundle' && (await shouldExtractZipPackage(destPath, packageFormat))) {
@@ -887,7 +896,7 @@ async function downloadBundle(downloadUrl, deploymentKey, label, expectedSize, o
         catch (error) {
             lastError = error;
             if (isRetryableDownloadError(error)) {
-                const recovered = await tryRecoverCompletedDownload(destPath, extension, totalBytes, expectedHash, packageFormat, label, deviceAbi);
+                const recovered = await tryRecoverCompletedDownload(destPath, extension, totalBytes, expectedHash, packageFormat, label, deviceAbi, extractApk);
                 if (recovered) {
                     if (onProgress)
                         onProgress(1);
@@ -1175,22 +1184,23 @@ async function performApkSync(update, showUI, messages, onProgress, changelog, c
     }
     const notes = changelog ?? getUpdateChangelog(update);
     const progressExtra = buildUpdateProgressExtra(update, undefined, currentLabel);
+    // Prefer zip (smaller). Native unwraps the APK before PackageInstaller runs.
     const packageFormat = update.packageFormat ?? 'zip';
     try {
         reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, 0, progressExtra);
-        const apkPath = await downloadBundle(update.downloadUrl, (0, config_1.getConfig)().deploymentKey, update.label, update.size, (p, received, total) => reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, p, {
+        const packagePath = await downloadBundle(update.downloadUrl, (0, config_1.getConfig)().deploymentKey, update.label, update.size, (p, received, total) => reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, p, {
             ...progressExtra,
             downloadedBytes: received,
             totalBytes: total && total > 0 ? total : progressExtra.totalBytes,
-        }), 'apk', update.deviceAbi, packageFormat, update.packageHash);
-        if (!apkPath.toLowerCase().endsWith('.apk')) {
-            throw new Error('Wrong package: expected an APK after zip extract');
+        }), 'apk', update.deviceAbi, packageFormat, update.packageHash, false);
+        const lowerPath = packagePath.toLowerCase();
+        if (!lowerPath.endsWith('.apk') && !lowerPath.endsWith('.zip')) {
+            throw new Error('Wrong package: expected an APK or zip-of-APK download');
         }
         onProgress?.(types_1.SyncStatus.INSTALLING, 1);
-        // Drop the OTA JS path before opening the installer so the new APK does not
-        // keep loading the previous bundle on first launch after install.
-        await clearUpdate();
-        const installResult = await installApk(apkPath);
+        // Drop only the OTA JS bundle — do not delete the APK/zip about to install.
+        await clearJsBundleState();
+        const installResult = await installApk(packagePath);
         if (installResult === 'permission_required') {
             reportProgress(showUI, messages, onProgress, types_1.SyncStatus.INSTALLING, 1, {
                 ...progressExtra,
@@ -1242,7 +1252,8 @@ async function getInstalledBundlePath() {
     }
     return null;
 }
-async function clearUpdate() {
+/** Clear persisted JS OTA state without touching APK/zip install candidates. */
+async function clearJsBundleState() {
     const meta = await getStoredBundleMeta();
     await clearStoredBundleMeta();
     if (OTAUpdaterNative?.clearBundlePath) {
@@ -1252,6 +1263,12 @@ async function clearUpdate() {
         await removePathRecursive(getBundleReleaseDir(meta.label));
         await cleanupPartialDownload(getBundleZipPath(meta.label));
         await cleanupPartialDownload(getLegacyBundleFilePath(meta.label));
+    }
+}
+async function clearUpdate() {
+    const meta = await getStoredBundleMeta();
+    await clearJsBundleState();
+    if (meta?.label) {
         await cleanupPartialDownload(getApkFilePath(meta.label));
         await cleanupPartialDownload(getApkZipPath(meta.label));
         await removePathRecursive(getApkExtractDir(meta.label));

package/package.json

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