@hot-updater/react-native 1.0.0-rc.1 → 1.0.0-rc.15

package/src/wrap.tsx

@@ -2,8 +2,8 @@ import React, { useEffect, useState } from "react";
 
 import { checkForUpdate } from "./checkForUpdate";
 import { useEventCallback } from "./hooks/useEventCallback";
-import { getBundleId, reload } from "./native";
-import { handleNotifyAppReady } from "./notifyAppReadyAnalytics";
+import { getUpdateId, reload } from "./native";
+import { handleNotifyAppReady, reportNoChange } from "./notifyAppReadyInsights";
 import { useHotUpdaterStore } from "./store";
 import type {
   InternalInitOptions,
@@ -45,8 +45,12 @@ export function wrap(
         try {
           setUpdateStatus("CHECK_FOR_UPDATE");
 
+          const readiness = handleNotifyAppReady({
+            ...restOptions,
+            reportUnchanged: false,
+          });
           const updateInfo = await checkForUpdate({
-            analytics: restOptions.analytics,
+            insights: restOptions.insights,
             client: restOptions.client,
             updateStrategy: restOptions.updateStrategy,
             requestHeaders: restOptions.requestHeaders,
@@ -54,14 +58,17 @@ export function wrap(
             onError: restOptions.onError,
           });
 
+          const launch = await readiness;
           setMessage(updateInfo?.message ?? null);
 
           if (!updateInfo) {
+            if (launch?.status === "UNCHANGED")
+              void reportNoChange(restOptions);
             restOptions.onUpdateProcessCompleted?.({
               status: "UP_TO_DATE",
               shouldForceUpdate: false,
               message: null,
-              id: getBundleId(),
+              id: getUpdateId(),
             });
             setUpdateStatus("UPDATE_PROCESS_COMPLETED");
             return;
@@ -115,11 +122,6 @@ export function wrap(
         restOptions.onProgress?.(progress);
       }, [progress]);
 
-      // Read the native launch report after the first render commit.
-      useEffect(() => {
-        void handleNotifyAppReady(restOptions);
-      }, []);
-
       // Start update check
       useEffect(() => {
         initHotUpdater();
@@ -134,11 +136,9 @@ export function wrap(
           <Fallback
             artifactType={progressState.artifactType}
             details={progressState.details}
-            downloadedBytes={progressState.downloadedBytes}
             progress={progress}
             status={updateStatus}
             message={message}
-            totalBytes={progressState.totalBytes}
           />
         );
       }

package/src/wrap.types.ts

@@ -21,8 +21,6 @@ export type UpdateStatus =
 export type HotUpdaterFallbackComponentProps = {
   status: Exclude<UpdateStatus, "UPDATE_PROCESS_COMPLETED">;
   progress: number;
-  downloadedBytes: HotUpdaterState["downloadedBytes"];
-  totalBytes: HotUpdaterState["totalBytes"];
   message: string | null;
   artifactType: HotUpdaterState["artifactType"];
   details: HotUpdaterState["details"];
@@ -31,9 +29,10 @@ export type HotUpdaterFallbackComponentProps = {
 interface CommonHotUpdaterOptions {
   /**
    * Sends app-ready transitions and same-Bundle Release adoptions to the
-   * configured server. Omit or set to `false` to disable client reporting.
+   * configured server. Defaults to `true`; set to `false` to disable client
+   * reporting.
    */
-  analytics?: boolean;
+  insights?: boolean;
   /** Base URL of a server exposing the Hot Updater v1 client HTTP protocol. */
   baseURL: HotUpdaterBaseURL;
   requestHeaders?: Record<string, string>;
@@ -55,7 +54,7 @@ export type HotUpdaterInitOptions = CommonHotUpdaterOptions;
 export type HotUpdaterOptions = AutoUpdateOptions;
 
 type InternalCommonOptions = {
-  analytics?: boolean;
+  insights?: boolean;
   client: HotUpdaterHttpClient;
   requestHeaders?: Record<string, string>;
   requestTimeout?: number;
@@ -71,8 +70,6 @@ type InternalAutoUpdateOptions = InternalCommonOptions & {
   onUpdateProcessCompleted?: (response: RunUpdateProcessResponse) => void;
 };
 
-export type InternalInitOptions = InternalCommonOptions & {
-  analytics?: boolean;
-};
+export type InternalInitOptions = InternalCommonOptions;
 
 export type InternalWrapOptions = InternalAutoUpdateOptions;

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

@@ -1,89 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.File
-
-/**
- * Unified decompression service that uses Strategy pattern to handle multiple compression formats.
- * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
- */
-class DecompressService {
-    companion object {
-        private const val TAG = "DecompressService"
-    }
-
-    // Strategies with reliable file signatures that can be validated cheaply.
-    // TAR.BR is attempted only as the final fallback because Brotli has no reliable magic bytes.
-    private val signatureStrategies =
-        listOf(
-            ZipDecompressionStrategy(),
-            TarGzDecompressionStrategy(),
-        )
-    private val tarBrStrategy = TarBrDecompressionStrategy()
-
-    /**
-     * Extracts a compressed file to the destination directory.
-     * Automatically detects compression format by trying each strategy's validation.
-     * @param filePath Path to the compressed file
-     * @param destinationPath Path to the destination directory
-     * @param progressCallback Callback for progress updates (0.0 - 1.0)
-     * @return true if extraction was successful, false otherwise
-     */
-    fun extractZipFile(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean {
-        // Collect file information for better error messages
-        val file = File(filePath)
-        val fileName = file.name
-        val fileSize = if (file.exists()) file.length() else 0L
-
-        // Try each signature-based strategy first.
-        for (strategy in signatureStrategies) {
-            if (strategy.isValid(filePath)) {
-                Log.d(TAG, "Using strategy for $fileName")
-                return strategy.decompress(filePath, destinationPath, progressCallback)
-            }
-        }
-
-        Log.d(TAG, "No ZIP/TAR.GZ signature matched for $fileName, trying TAR.BR fallback")
-
-        if (tarBrStrategy.decompress(filePath, destinationPath, progressCallback)) {
-            Log.d(TAG, "Using TAR.BR fallback for $fileName")
-            return true
-        }
-
-        val errorMessage = createInvalidArchiveMessage(fileName, fileSize)
-        Log.e(TAG, errorMessage)
-        return false
-    }
-
-    /**
-     * Validates if a file matches one of the signature-based archive formats.
-     * @param filePath Path to the file to validate
-     * @return true if the file is a valid compressed archive
-     */
-    fun isValidZipFile(filePath: String): Boolean {
-        for (strategy in signatureStrategies) {
-            if (strategy.isValid(filePath)) {
-                return true
-            }
-        }
-        Log.d(TAG, "No ZIP/TAR.GZ signature matched for file: $filePath. TAR.BR is handled during extraction fallback.")
-        return false
-    }
-
-    private fun createInvalidArchiveMessage(
-        fileName: String,
-        fileSize: Long,
-    ): String =
-        """
-        The downloaded bundle file is not a valid compressed archive: $fileName ($fileSize bytes)
-
-        Supported formats:
-        - ZIP archives (.zip)
-        - GZIP compressed TAR archives (.tar.gz)
-        - Brotli compressed TAR archives (.tar.br)
-        """.trimIndent()
-}

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

@@ -1,26 +0,0 @@
-package com.hotupdater
-
-/**
- * Interface for decompression strategies
- */
-interface DecompressionStrategy {
-    /**
-     * Validates if a file can be decompressed by this strategy
-     * @param filePath Path to the file to validate
-     * @return true if the file is valid for this strategy
-     */
-    fun isValid(filePath: String): Boolean
-
-    /**
-     * Decompresses a file to the destination directory
-     * @param filePath Path to the compressed file
-     * @param destinationPath Path to the destination directory
-     * @param progressCallback Callback for progress updates (0.0 - 1.0)
-     * @return true if decompression was successful, false otherwise
-     */
-    fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean
-}

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

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import com.hotupdater.vendor.brotli.dec.BrotliInputStream
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-
-/**
- * Strategy for handling TAR+Brotli compressed files
- * Uses native Brotli decoder and custom TAR parser
- */
-class TarBrDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarBrStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        return try {
-            FileInputStream(file).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            val firstEntry = tarInputStream.getNextEntry()
-                            val isValid = firstEntry != null
-
-                            if (!isValid) {
-                                Log.d(TAG, "Invalid file: tar archive has no entries")
-                            }
-
-                            isValid
-                        }
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: Brotli/TAR validation failed - ${e.message}")
-            false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.br file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.br file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.d(TAG, "Failed to extract tar.br file: ${e.message}")
-            e.printStackTrace()
-            false
-        }
-}

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

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.util.zip.GZIPInputStream
-
-/**
- * Strategy for handling TAR+GZIP compressed files
- * Uses native GZIP decoder and custom TAR parser
- */
-class TarGzDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarGzStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        try {
-            FileInputStream(file).use { fis ->
-                val header = ByteArray(2)
-                if (fis.read(header) != 2) {
-                    Log.d(TAG, "Invalid file: cannot read header")
-                    return false
-                }
-
-                // Check GZIP magic bytes (0x1F 0x8B)
-                val isGzip = header[0] == 0x1F.toByte() && header[1] == 0x8B.toByte()
-                if (!isGzip) {
-                    Log.d(
-                        TAG,
-                        "Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x${header[0].toString(16)} 0x${header[1].toString(16)})",
-                    )
-                }
-                return isGzip
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: error reading header: ${e.message}")
-            return false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.gz file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    GZIPInputStream(bufferedInputStream).use { gzipInputStream ->
-                        TarArchiveInputStream(gzipInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.gz file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error extracting tar.gz file: ${e.message}", e)
-            false
-        }
-}

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

@@ -1,192 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.io.IOException
-import java.util.zip.CRC32
-import java.util.zip.ZipEntry
-import java.util.zip.ZipException
-import java.util.zip.ZipFile
-import java.util.zip.ZipInputStream
-
-/**
- * Strategy for handling ZIP compressed files
- */
-class ZipDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "ZipStrategy"
-        private const val MIN_ZIP_SIZE = 22L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_ZIP_SIZE) {
-            Log.d(TAG, "Invalid ZIP: file doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        try {
-            FileInputStream(file).use { fis ->
-                val header = ByteArray(4)
-                if (fis.read(header) != 4) {
-                    Log.d(TAG, "Invalid ZIP: cannot read header")
-                    return false
-                }
-
-                // ZIP magic bytes: 0x50 0x4B 0x03 0x04 ("PK\u0003\u0004")
-                val expectedMagic = byteArrayOf(0x50.toByte(), 0x4B.toByte(), 0x03.toByte(), 0x04.toByte())
-
-                if (!header.contentEquals(expectedMagic)) {
-                    val headerHex = header.joinToString(" ") { "0x%02X".format(it) }
-                    Log.d(TAG, "Invalid ZIP: wrong magic bytes (expected 0x50 0x4B 0x03 0x04, got $headerHex)")
-                    return false
-                }
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid ZIP: error reading file: ${e.message}")
-            return false
-        }
-
-        try {
-            ZipFile(file).use { zipFile ->
-                val entries = zipFile.entries()
-                if (!entries.hasMoreElements()) {
-                    Log.d(TAG, "Invalid ZIP: no entries found")
-                    return false
-                }
-
-                val firstEntry = entries.nextElement()
-                zipFile.getInputStream(firstEntry).use { stream ->
-                    val buffer = ByteArray(1024)
-                    stream.read(buffer)
-                }
-            }
-            return true
-        } catch (e: ZipException) {
-            Log.d(TAG, "Invalid ZIP: ZIP structure error: ${e.message}")
-            return false
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid ZIP: validation error: ${e.message}")
-            return false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean {
-        return try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            // Calculate total bytes to extract for accurate progress reporting
-            val totalBytes =
-                try {
-                    ZipFile(File(filePath)).use { zipFile ->
-                        zipFile
-                            .entries()
-                            .asSequence()
-                            .filter { !it.isDirectory }
-                            .sumOf { it.size }
-                    }
-                } catch (e: Exception) {
-                    Log.d(TAG, "Failed to calculate total bytes: ${e.message}")
-                    0L
-                }
-
-            if (totalBytes == 0L) {
-                Log.d(TAG, "No content found in ZIP")
-                return false
-            }
-
-            Log.d(TAG, "Extracting $totalBytes bytes from ZIP")
-
-            var extractedFileCount = 0
-            var extractedBytes = 0L
-            var lastReportedProgress = 0.0
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    ZipInputStream(bufferedInputStream).use { zipInputStream ->
-                        var entry: ZipEntry? = zipInputStream.nextEntry
-                        while (entry != null) {
-                            val file =
-                                try {
-                                    RelativePathResolver.resolveInside(destinationDir, entry.name)
-                                } catch (e: IOException) {
-                                    Log.w(TAG, "Failed to resolve canonical path for zip entry: ${entry.name}", e)
-                                    null
-                                }
-
-                            if (file == null) {
-                                Log.w(TAG, "Skipping potentially malicious zip entry: ${entry.name}")
-                                entry = zipInputStream.nextEntry
-                                continue
-                            }
-
-                            if (entry.isDirectory) {
-                                file.mkdirs()
-                            } else {
-                                file.parentFile?.mkdirs()
-
-                                val crc = CRC32()
-                                FileOutputStream(file).use { output ->
-                                    val buffer = ByteArray(8 * 1024)
-                                    var bytesRead: Int
-
-                                    while (zipInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                        output.write(buffer, 0, bytesRead)
-                                        crc.update(buffer, 0, bytesRead)
-
-                                        // Track bytes written for byte-based progress
-                                        extractedBytes += bytesRead
-
-                                        // Report progress more frequently (every 1%)
-                                        val currentProgress = extractedBytes.toDouble() / totalBytes
-                                        if (currentProgress - lastReportedProgress >= 0.01) {
-                                            progressCallback.invoke(currentProgress)
-                                            lastReportedProgress = currentProgress
-                                        }
-                                    }
-                                }
-
-                                if (entry.crc != -1L && crc.value != entry.crc) {
-                                    Log.w(TAG, "CRC mismatch for ${entry.name}: expected ${entry.crc}, got ${crc.value}")
-                                    file.delete()
-                                    return false
-                                }
-
-                                extractedFileCount++
-                            }
-
-                            zipInputStream.closeEntry()
-                            entry = zipInputStream.nextEntry
-                        }
-                    }
-                }
-            }
-
-            if (extractedFileCount == 0) {
-                Log.d(TAG, "No files extracted from ZIP")
-                return false
-            }
-
-            Log.d(TAG, "Successfully extracted $extractedFileCount files ($extractedBytes bytes)")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: ZipException) {
-            Log.d(TAG, "ZIP extraction failed: ${e.message}")
-            false
-        } catch (e: Exception) {
-            Log.d(TAG, "Failed to unzip file: ${e.message}")
-            false
-        }
-    }
-}