react-native-ota-sdk 1.0.0

package/functions/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "react-native-ota-sdk-functions",
+  "version": "1.0.0",
+  "description": "Firebase Cloud Functions for react-native-ota-sdk - auto-updates Remote Config when APK is uploaded to Storage",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "serve": "npm run build && firebase emulators:start --only functions",
+    "deploy": "npm run build && firebase deploy --only functions"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "firebase-admin": "^12.0.0",
+    "firebase-functions": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "private": true
+}

package/functions/src/index.ts

@@ -0,0 +1,146 @@
+// Firebase Functions v2 Storage trigger - fires when a file is uploaded to Storage
+import {onObjectFinalized} from "firebase-functions/v2/storage";
+import {defineString} from "firebase-functions/params";
+// Admin SDK for accessing Storage and Remote Config
+import {getStorage} from "firebase-admin/storage";
+import {getRemoteConfig} from "firebase-admin/remote-config";
+import {initializeApp} from "firebase-admin/app";
+import {logger} from "firebase-functions";
+import type {StorageEvent} from "firebase-functions/v2/storage";
+
+// Initialize Firebase Admin (required before using any Admin SDK services)
+initializeApp();
+
+// Configurable via Firebase config or environment - e.g. apks/myapp/
+const apkPathPrefix = defineString("APK_PATH_PREFIX", {default: "apks/default/"});
+const FUNCTION_REGION = process.env.REGION || "us-central1";
+
+/**
+ * Cloud Function: onApkUploaded
+ *
+ * Triggered when any file is uploaded to Firebase Storage.
+ * If the file is an APK under the configured APK_PATH_PREFIX, updates Firebase Remote Config with:
+ *   - apk_url: public download URL for the APK
+ *   - latest_version: version number extracted from filename (e.g. v2.apk -> 2)
+ *
+ * The mobile app reads these values to show OTA (over-the-air) update prompts.
+ *
+ * Configuration (set via Firebase config or .env):
+ *   APK_PATH_PREFIX - Storage path to watch (default: apks/default/)
+ *   REGION - Function region (default: us-central1)
+ */
+export const onApkUploaded = onObjectFinalized(
+  {
+    region: FUNCTION_REGION,
+  },
+  async (event: StorageEvent) => {
+    const prefix = apkPathPrefix.value();
+    if (!prefix.endsWith("/")) {
+      logger.warn("APK_PATH_PREFIX should end with /, normalizing");
+    }
+    const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+
+    // --- Extract event data ---
+    const filePath = event.data?.name; // e.g. "apks/myapp/v2.apk"
+    const bucket = event.data?.bucket;
+    const contentType = event.data?.contentType; // e.g. "application/vnd.android.package-archive"
+
+    logger.info("onApkUploaded triggered", {filePath, bucket, contentType, prefix: normalizedPrefix});
+
+    // --- Validate required fields ---
+    if (!filePath || !bucket) {
+      logger.warn("Missing file path or bucket in event");
+      return;
+    }
+
+    // --- Filter: only process files in our APK folder ---
+    if (!filePath.startsWith(normalizedPrefix)) {
+      logger.info(`Skipping non-APK path: ${filePath} (expected prefix: ${normalizedPrefix})`);
+      return;
+    }
+
+    // --- Filter: only process APK files (by content type) ---
+    // Some uploads may have no contentType; octet-stream is a common fallback
+    const isApkByType =
+      !contentType ||
+      contentType === "application/vnd.android.package-archive" ||
+      contentType === "application/octet-stream";
+    if (!isApkByType) {
+      logger.info(`Skipping non-APK content type: ${contentType}`);
+      return;
+    }
+
+    try {
+      // --- Get Storage reference and file metadata ---
+      const storage = getStorage();
+      const file = storage.bucket(bucket).file(filePath);
+      const [metadata] = await file.getMetadata();
+
+      // Firebase Storage adds a download token for public URLs; use it if present
+      const token = (metadata.metadata as Record<string, string> | undefined)
+        ?.firebaseStorageDownloadTokens;
+      const encodedPath = encodeURIComponent(filePath);
+
+      // --- Build download URL ---
+      let downloadUrl: string;
+      if (token) {
+        // Public URL format: works when file is publicly readable
+        downloadUrl = `https://firebasestorage.googleapis.com/v0/b/${bucket}/o/${encodedPath}?alt=media&token=${token}`;
+      } else {
+        // Fallback: generate a signed URL (valid 1 year) if no token
+        const [signedUrl] = await file.getSignedUrl({
+          action: "read",
+          expires: Date.now() + 365 * 24 * 60 * 60 * 1000,
+        });
+        downloadUrl = signedUrl;
+      }
+
+      logger.info("APK upload detected", {filePath, downloadUrl});
+
+      // --- Fetch current Remote Config template ---
+      const remoteConfig = getRemoteConfig();
+      const template = await remoteConfig.getTemplate();
+
+      if (!template.parameters) {
+        template.parameters = {};
+      }
+
+      // --- Update apk_url parameter ---
+      // The app reads this to download the APK when an update is available
+      template.parameters["apk_url"] = {
+        defaultValue: {
+          value: downloadUrl,
+        },
+        description: "APK download URL - auto-updated when APK is uploaded to Storage",
+      };
+
+      // --- Extract version from filename and update latest_version ---
+      // Supports: v2.apk, 2.apk, v1_2_3.apk (uses first number)
+      const versionMatch = filePath.match(/v?(\d+)\.apk$/i) ||
+        filePath.match(/v?(\d+)_(\d+)_(\d+)\.apk$/i);
+      if (versionMatch) {
+        const versionNum = versionMatch[1];
+        const version = parseInt(versionNum, 10);
+        if (!isNaN(version)) {
+          template.parameters["latest_version"] = {
+            defaultValue: {
+              value: String(version),
+            },
+            valueType: "NUMBER",
+            description: "Latest app version - auto-updated from APK filename",
+          };
+          logger.info("Updated latest_version from filename", {version});
+        }
+      }
+
+      // --- Publish updated template to Remote Config ---
+      const validated = await remoteConfig.validateTemplate(template);
+      await remoteConfig.publishTemplate(validated);
+
+      logger.info("Remote Config updated successfully with new apk_url");
+    } catch (err) {
+      logger.error("Failed to update Remote Config", err);
+      throw err;
+    }
+  }
+);

package/functions/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "outDir": "lib",
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2017"
+  },
+  "compileOnSave": true,
+  "include": ["src"]
+}

package/index.js

@@ -0,0 +1,7 @@
+import OTAUpdater from './src/OTAUpdater';
+import VersionChecker from './src/VersionChecker';
+import NetworkMonitor from './src/NetworkMonitor';
+
+export { OTAUpdater, VersionChecker, NetworkMonitor };
+export default OTAUpdater;
+

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "react-native-ota-sdk",
+  "version": "1.0.0",
+  "description": "React Native SDK for seamless Over-The-Air (OTA) updates. Supports major APK updates and minor JavaScript bundle updates with WiFi force-update capabilities. Optional Firebase backend: upload APK to Storage → Cloud Function updates Remote Config → app fetches config. No server needed. Compatible with React Native old and new architecture (TurboModules).",
+  "main": "index.js",
+  "files": [
+    "android",
+    "src",
+    "functions",
+    "index.js",
+    "react-native.config.js",
+    "README.md",
+    "ANDROID_SETUP.md",
+    "TESTING.md"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native",
+    "ota",
+    "over-the-air",
+    "updates",
+    "apk",
+    "bundle",
+    "hot-update",
+    "code-push",
+    "turbo-modules",
+    "new-architecture",
+    "firebase",
+    "remote-config"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/126punith/react-native-ota-console.git",
+    "directory": "react-native-ota-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/126punith/react-native-ota-console/issues"
+  },
+  "homepage": "https://github.com/126punith/react-native-ota-console#readme",
+  "peerDependencies": {
+    "react-native": ">=0.60.0"
+  },
+  "dependencies": {
+    "react-native-fs": "^2.20.0",
+    "@react-native-community/netinfo": "^11.0.0",
+    "react-native-install-apk": "^1.1.0"
+  },
+  "devDependencies": {
+    "react-native": "^0.72.0"
+  },
+  "react-native": {
+    "android": {
+      "sourceDir": "./android",
+      "packageImportPath": "import com.otaupdater.react.OTAPackage;"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: '../android',
+        packageImportPath: 'import com.otaupdater.react.OTAPackage;',
+      },
+    },
+  },
+};
+

package/src/ApkDownloader.js

@@ -0,0 +1,383 @@
+import { Platform, Alert, Linking } from 'react-native';
+
+// Optional imports - handle gracefully if not available
+let RNFS = null;
+let InstallApk = null;
+
+try {
+  RNFS = require('react-native-fs');
+} catch (e) {
+  console.warn('react-native-fs not available');
+}
+
+try {
+  InstallApk = require('react-native-install-apk');
+} catch (e) {
+  console.warn('react-native-install-apk not available, using fallback');
+}
+
+class ApkDownloader {
+  constructor(config) {
+    this.onProgress = config.onProgress || (() => {});
+    this.onError = config.onError || (() => {});
+    this.onSuccess = config.onSuccess || (() => {});
+  }
+
+  async downloadApk(downloadUrl, versionName) {
+    try {
+      if (!RNFS) {
+        throw new Error('react-native-fs is required for APK downloads');
+      }
+
+      console.log(`📥 [ApkDownloader] Starting download: ${versionName} from ${downloadUrl}`);
+
+      // Debug: Log all available paths
+      console.log(`🔍 [ApkDownloader] Available paths:`, {
+        CachesDirectoryPath: RNFS.CachesDirectoryPath || 'NOT AVAILABLE',
+        ExternalStorageDirectoryPath: RNFS.ExternalStorageDirectoryPath || 'NOT AVAILABLE',
+        ExternalDirectoryPath: RNFS.ExternalDirectoryPath || 'NOT AVAILABLE',
+        DocumentDirectoryPath: RNFS.DocumentDirectoryPath || 'NOT AVAILABLE',
+        DownloadDirectoryPath: RNFS.DownloadDirectoryPath || 'NOT AVAILABLE',
+        MainBundlePath: RNFS.MainBundlePath || 'NOT AVAILABLE',
+      });
+
+      // Try different base paths in order of preference for Android scoped storage compatibility
+      // Prefer CachesDirectoryPath or ExternalStorageDirectoryPath (Android 10+ compatible)
+      // over DownloadDirectoryPath which may have scoped storage restrictions
+      let downloadPath = null;
+      let basePath = null;
+      let pathSource = null;
+      
+      // Priority order for Android scoped storage compatibility:
+      // 1. CachesDirectoryPath - always accessible, good for temporary APK downloads (app-specific, no permissions needed)
+      // 2. ExternalStorageDirectoryPath - app's external storage directory (app-specific, usually accessible)
+      // 3. DocumentDirectoryPath - app's document directory (app-specific)
+      // 4. DownloadDirectoryPath - may have restrictions on Android 10+ (requires permissions, may fail)
+      
+      // Explicitly prefer app-specific directories that don't require external storage permissions
+      if (RNFS.CachesDirectoryPath && typeof RNFS.CachesDirectoryPath === 'string' && RNFS.CachesDirectoryPath.length > 0) {
+        basePath = RNFS.CachesDirectoryPath;
+        downloadPath = `${basePath}/OTA_Updates`;
+        pathSource = 'CachesDirectoryPath';
+        console.log(`✅ [ApkDownloader] Selected CachesDirectoryPath: ${downloadPath}`);
+      } else if (RNFS.ExternalStorageDirectoryPath && typeof RNFS.ExternalStorageDirectoryPath === 'string' && RNFS.ExternalStorageDirectoryPath.length > 0) {
+        basePath = RNFS.ExternalStorageDirectoryPath;
+        downloadPath = `${basePath}/OTA_Updates`;
+        pathSource = 'ExternalStorageDirectoryPath';
+        console.log(`✅ [ApkDownloader] Selected ExternalStorageDirectoryPath: ${downloadPath}`);
+      } else if (RNFS.ExternalDirectoryPath && typeof RNFS.ExternalDirectoryPath === 'string' && RNFS.ExternalDirectoryPath.length > 0) {
+        basePath = RNFS.ExternalDirectoryPath;
+        downloadPath = `${basePath}/OTA_Updates`;
+        pathSource = 'ExternalDirectoryPath';
+        console.log(`✅ [ApkDownloader] Selected ExternalDirectoryPath: ${downloadPath}`);
+      } else if (RNFS.DocumentDirectoryPath && typeof RNFS.DocumentDirectoryPath === 'string' && RNFS.DocumentDirectoryPath.length > 0) {
+        basePath = RNFS.DocumentDirectoryPath;
+        downloadPath = `${basePath}/OTA_Updates`;
+        pathSource = 'DocumentDirectoryPath';
+        console.log(`✅ [ApkDownloader] Selected DocumentDirectoryPath: ${downloadPath}`);
+      } else if (RNFS.DownloadDirectoryPath && typeof RNFS.DownloadDirectoryPath === 'string' && RNFS.DownloadDirectoryPath.length > 0) {
+        basePath = RNFS.DownloadDirectoryPath;
+        downloadPath = `${basePath}/OTA_Updates`;
+        pathSource = 'DownloadDirectoryPath';
+        console.log(`⚠️ [ApkDownloader] WARNING: Using DownloadDirectoryPath (fallback) - may have Android 10+ scoped storage restrictions: ${downloadPath}`);
+      } else {
+        throw new Error('No valid download directory available. Check react-native-fs installation and ensure native modules are properly linked.');
+      }
+
+      console.log(`📁 [ApkDownloader] Selected base path: ${basePath} (${pathSource})`);
+      console.log(`📁 [ApkDownloader] Target download directory: ${downloadPath}`);
+
+      // Verify base directory exists
+      const baseExists = await RNFS.exists(basePath);
+      if (!baseExists) {
+        throw new Error(`Base directory does not exist: ${basePath} (${pathSource})`);
+      }
+      console.log(`✅ [ApkDownloader] Base directory exists: ${basePath}`);
+
+      // Create directory recursively by creating parent directories one by one
+      const pathParts = downloadPath.split('/').filter(part => part.length > 0);
+      let currentPath = pathParts[0] === '' ? '/' : pathParts[0];
+      
+      for (let i = 1; i < pathParts.length; i++) {
+        currentPath += '/' + pathParts[i];
+        const exists = await RNFS.exists(currentPath);
+        if (!exists) {
+          console.log(`📁 [ApkDownloader] Creating directory: ${currentPath}`);
+          try {
+            await RNFS.mkdir(currentPath);
+            // Verify directory was actually created
+            const created = await RNFS.exists(currentPath);
+            if (!created) {
+              throw new Error(`Directory creation reported success but directory does not exist: ${currentPath}`);
+            }
+            console.log(`✅ [ApkDownloader] Directory created successfully: ${currentPath}`);
+          } catch (mkdirError) {
+            // If mkdir fails, check if directory was created by another process
+            const existsAfterError = await RNFS.exists(currentPath);
+            if (!existsAfterError) {
+              throw new Error(`Failed to create directory: ${currentPath}. Error: ${mkdirError.message}. Path source: ${pathSource}`);
+            }
+            console.log(`✅ [ApkDownloader] Directory already exists (created by another process): ${currentPath}`);
+          }
+        } else {
+          console.log(`✅ [ApkDownloader] Directory already exists: ${currentPath}`);
+        }
+      }
+
+      // Final verification: ensure the download directory exists before proceeding
+      const downloadDirExists = await RNFS.exists(downloadPath);
+      if (!downloadDirExists) {
+        throw new Error(`Download directory does not exist after creation attempt: ${downloadPath}. This may be due to Android scoped storage restrictions.`);
+      }
+      console.log(`✅ [ApkDownloader] Download directory verified: ${downloadPath}`);
+
+      const fileName = `app-update-${versionName}.apk`;
+      const filePath = `${downloadPath}/${fileName}`;
+
+      console.log(`📁 [ApkDownloader] Target file path: ${filePath}`);
+
+      // Delete existing file if present
+      if (await RNFS.exists(filePath)) {
+        console.log(`🗑️ [ApkDownloader] Deleting existing file: ${filePath}`);
+        try {
+          await RNFS.unlink(filePath);
+          console.log(`✅ [ApkDownloader] Existing file deleted`);
+        } catch (unlinkError) {
+          console.warn(`⚠️ [ApkDownloader] Failed to delete existing file (may not exist): ${unlinkError.message}`);
+        }
+      }
+
+      // One final check: verify directory still exists before starting download
+      const finalDirCheck = await RNFS.exists(downloadPath);
+      if (!finalDirCheck) {
+        throw new Error(`Download directory disappeared before download: ${downloadPath}. Check Android storage permissions.`);
+      }
+
+      // Test write access to the directory by attempting to write a small test file
+      const testFilePath = `${downloadPath}/.test_write`;
+      try {
+        console.log(`🧪 [ApkDownloader] Testing write access to directory: ${downloadPath}`);
+        await RNFS.writeFile(testFilePath, 'test', 'utf8');
+        const testFileExists = await RNFS.exists(testFilePath);
+        if (testFileExists) {
+          await RNFS.unlink(testFilePath);
+          console.log(`✅ [ApkDownloader] Write access verified for directory: ${downloadPath}`);
+        } else {
+          throw new Error(`Write test failed: test file was not created at ${testFilePath}`);
+        }
+      } catch (writeTestError) {
+        throw new Error(`Cannot write to directory ${downloadPath}. This may be due to Android scoped storage restrictions or missing permissions. Error: ${writeTestError.message}. Try using an app-specific directory.`);
+      }
+
+      console.log(`⬇️ [ApkDownloader] Starting file download to: ${filePath}`);
+      const downloadResult = RNFS.downloadFile({
+        fromUrl: downloadUrl,
+        toFile: filePath,
+        progress: (res) => {
+          const progress = (res.bytesWritten / res.contentLength) * 100;
+          this.onProgress(progress, res.bytesWritten, res.contentLength);
+        },
+        background: false, // Set to false to avoid issues with scoped storage
+        discretionary: false,
+        cacheable: false,
+      });
+
+      const result = await downloadResult.promise;
+
+      console.log(`📊 [ApkDownloader] Download completed with status: ${result.statusCode}`);
+
+      if (result.statusCode === 200) {
+        // Verify file exists after download
+        const fileExists = await RNFS.exists(filePath);
+        if (!fileExists) {
+          throw new Error(`Download completed with status 200 but file not found at: ${filePath}`);
+        }
+
+        // Verify file size is reasonable (not empty)
+        try {
+          const stat = await RNFS.stat(filePath);
+          console.log(`📊 [ApkDownloader] File size: ${(stat.size / 1024 / 1024).toFixed(2)} MB`);
+          
+          if (stat.size === 0) {
+            throw new Error(`Downloaded file is empty (0 bytes): ${filePath}`);
+          }
+          
+          // APK files should be at least a few KB (very small threshold)
+          if (stat.size < 1024) {
+            throw new Error(`Downloaded file is suspiciously small (${stat.size} bytes). Expected APK file.`);
+          }
+        } catch (statError) {
+          throw new Error(`Failed to verify downloaded file: ${statError.message}`);
+        }
+
+        console.log(`✅ [ApkDownloader] Download successful: ${filePath}`);
+        this.onSuccess(filePath);
+        return filePath;
+      } else {
+        throw new Error(`Download failed with HTTP status: ${result.statusCode}. Check server logs for details.`);
+      }
+    } catch (error) {
+      console.error(`❌ [ApkDownloader] Download error:`, {
+        message: error.message,
+        versionName,
+        downloadUrl,
+        error: error
+      });
+      this.onError(error);
+      throw error;
+    }
+  }
+
+  async installApk(filePath) {
+    console.log('🚀 [ApkDownloader] installApk called with filePath:', filePath);
+    console.log('🚀 [ApkDownloader] Platform.OS:', Platform.OS);
+    
+    try {
+      if (Platform.OS !== 'android') {
+        throw new Error('APK installation is only supported on Android');
+      }
+
+      // Check if file exists
+      console.log('🔍 [ApkDownloader] Checking if file exists:', filePath);
+      const exists = await RNFS.exists(filePath);
+      console.log('🔍 [ApkDownloader] File exists:', exists);
+      if (!exists) {
+        throw new Error('APK file not found');
+      }
+
+      // Try to use native module for direct installation (preferred method)
+      try {
+        const { NativeModules } = require('react-native');
+        
+        // Debug: Log all available native modules
+        console.log('🔍 [ApkDownloader] All available NativeModules:', Object.keys(NativeModules));
+        console.log('🔍 [ApkDownloader] NativeModules.OTANative:', NativeModules.OTANative);
+        console.log('🔍 [ApkDownloader] NativeModules type:', typeof NativeModules);
+        
+        // Try to access via NativeBundleManager to see if it's available there
+        try {
+          const NativeBundleManager = require('./NativeBundleManager').default;
+          console.log('🔍 [ApkDownloader] NativeBundleManager.isAvailable:', NativeBundleManager.isAvailable);
+          if (NativeBundleManager.isAvailable) {
+            console.log('🔍 [ApkDownloader] NativeBundleManager can access OTANative - checking methods');
+            try {
+              const config = await NativeBundleManager.getConfiguration();
+              console.log('🔍 [ApkDownloader] NativeBundleManager.getConfiguration result:', config);
+            } catch (configError) {
+              console.warn('⚠️ [ApkDownloader] getConfiguration failed:', configError.message);
+            }
+          }
+        } catch (e) {
+          console.warn('⚠️ [ApkDownloader] Could not check NativeBundleManager:', e.message);
+        }
+        
+        const OTANative = NativeModules.OTANative;
+        
+        console.log('🔍 [ApkDownloader] Checking native module:', {
+          hasOTANativeModule: !!OTANative,
+          hasInstallMethod: OTANative ? !!OTANative.installApk : false,
+          filePath: filePath,
+          OTANativeType: typeof OTANative,
+          OTANativeValue: OTANative,
+          allNativeModuleKeys: Object.keys(NativeModules)
+        });
+        
+        if (OTANative && OTANative.installApk) {
+          console.log('📦 [ApkDownloader] Calling native installApk for:', filePath);
+          await OTANative.installApk(filePath);
+          console.log('✅ [ApkDownloader] Native installation intent launched successfully');
+          return true;
+        } else {
+          console.warn('⚠️ [ApkDownloader] Native module or installApk method not available, trying fallback');
+        }
+      } catch (nativeError) {
+        console.error('❌ [ApkDownloader] Native installation error:', nativeError);
+        console.warn('⚠️ [ApkDownloader] Native installation failed, trying fallback:', nativeError.message);
+      }
+
+      // Fallback: Try FileProvider URI with Linking (Android 7.0+)
+      if (Platform.Version >= 24) {
+        try {
+          const { NativeModules } = require('react-native');
+          const OTANative = NativeModules.OTANative;
+          
+          if (OTANative && OTANative.getFileProviderUri) {
+            console.log('📦 [ApkDownloader] Trying FileProvider URI fallback');
+            const contentUri = await OTANative.getFileProviderUri(filePath);
+            console.log('📦 [ApkDownloader] Received FileProvider URI:', contentUri);
+            
+            if (contentUri && contentUri.startsWith('content://')) {
+              const supported = await Linking.canOpenURL(contentUri);
+              if (supported) {
+                console.log('🚀 [ApkDownloader] Opening URI for installation:', contentUri);
+                await Linking.openURL(contentUri);
+                console.log('✅ [ApkDownloader] Installation intent launched via URI');
+                return true;
+              }
+            }
+          }
+        } catch (uriError) {
+          console.warn('⚠️ [ApkDownloader] FileProvider URI fallback failed:', uriError.message);
+        }
+      }
+
+      // Fallback: Try react-native-install-apk if available
+      if (InstallApk) {
+        try {
+          console.log('📦 [ApkDownloader] Trying react-native-install-apk fallback');
+          await InstallApk.installApk(filePath);
+          console.log('✅ [ApkDownloader] Installation via react-native-install-apk succeeded');
+          return true;
+        } catch (installError) {
+          console.warn('⚠️ [ApkDownloader] InstallApk failed:', installError);
+        }
+      }
+
+      // Last resort: Try file:// URI (may fail on Android 7.0+)
+      console.log('📦 [ApkDownloader] Trying file:// URI as last resort');
+      const supported = await Linking.canOpenURL(`file://${filePath}`);
+      if (supported) {
+        await Linking.openURL(`file://${filePath}`);
+        console.log('✅ [ApkDownloader] Installation intent launched via file:// URI');
+        return true;
+      }
+
+      throw new Error('Unable to open APK file for installation. All installation methods failed.');
+    } catch (error) {
+      console.error('APK installation error:', error);
+      throw error;
+    }
+  }
+
+  showInstallPrompt(filePath, versionName, releaseNotes) {
+    Alert.alert(
+      'Update Available',
+      `A new version (${versionName}) is available. Would you like to install it now?${
+        releaseNotes ? `\n\n${releaseNotes}` : ''
+      }`,
+      [
+        {
+          text: 'Later',
+          style: 'cancel',
+        },
+        {
+          text: 'Install',
+          onPress: () => this.installApk(filePath),
+        },
+      ],
+      { cancelable: false }
+    );
+  }
+
+  showForceUpdateAlert() {
+    Alert.alert(
+      'Update Required',
+      'A critical update is available. The app will be updated now.',
+      [{ text: 'OK' }],
+      { cancelable: false }
+    );
+  }
+}
+
+export default ApkDownloader;
+