react-native-ota-sdk 1.0.0

package/src/BundleUpdater.js

@@ -0,0 +1,182 @@
+import { NativeModules, Platform, DeviceEventEmitter } from 'react-native';
+import NativeBundleManager from './NativeBundleManager';
+
+// Optional import
+let RNFS = null;
+try {
+  RNFS = require('react-native-fs');
+} catch (e) {
+  console.warn('react-native-fs not available');
+}
+
+class BundleUpdater {
+  constructor(config) {
+    this.onProgress = config.onProgress || (() => {});
+    this.onError = config.onError || (() => {});
+    this.onSuccess = config.onSuccess || (() => {});
+    this.bundleCacheDir = RNFS ? `${RNFS.CachesDirectoryPath}/OTA_Bundles` : '/tmp/OTA_Bundles';
+    this.useNativeModule = NativeBundleManager.isAvailable && Platform.OS === 'android';
+    
+    // Set up download progress listener if native module is available
+    if (this.useNativeModule) {
+      DeviceEventEmitter.addListener('OTADownloadProgress', (progress) => {
+        const progressPercent = progress.totalBytes > 0 
+          ? (progress.receivedBytes / progress.totalBytes) * 100 
+          : 0;
+        this.onProgress(progressPercent, progress.receivedBytes, progress.totalBytes);
+      });
+    }
+  }
+
+  async ensureCacheDir() {
+    if (!RNFS && !this.useNativeModule) {
+      throw new Error('react-native-fs is required for bundle updates when native module is not available');
+    }
+    if (RNFS) {
+    const exists = await RNFS.exists(this.bundleCacheDir);
+    if (!exists) {
+      await RNFS.mkdir(this.bundleCacheDir);
+      }
+    }
+  }
+
+  async downloadBundle(downloadUrl, versionName) {
+    try {
+      // Use native module if available (Android only)
+      if (this.useNativeModule) {
+        console.log('📦 [BundleUpdater] Using native module for bundle download');
+        const packageInfo = await NativeBundleManager.downloadBundle(downloadUrl, versionName);
+        
+        // Get bundle path from package info
+        const bundlePath = packageInfo?.bundlePath || packageInfo?.relativeBundlePath;
+        if (bundlePath) {
+          this.onSuccess(bundlePath);
+          return bundlePath;
+        }
+        throw new Error('Bundle path not found in package info');
+      }
+
+      // Fallback to RNFS download
+      await this.ensureCacheDir();
+
+      const fileName = `bundle-${versionName}.bundle`;
+      const filePath = `${this.bundleCacheDir}/${fileName}`;
+
+      // Delete existing bundle if present
+      if (await RNFS.exists(filePath)) {
+        await RNFS.unlink(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: true,
+        discretionary: true,
+        cacheable: false,
+      });
+
+      const result = await downloadResult.promise;
+
+      if (result.statusCode === 200) {
+        this.onSuccess(filePath);
+        return filePath;
+      } else {
+        throw new Error(`Bundle download failed with status: ${result.statusCode}`);
+      }
+    } catch (error) {
+      console.error('Bundle download error:', error);
+      this.onError(error);
+      throw error;
+    }
+  }
+
+  async loadBundle(bundlePath) {
+    try {
+      // Use native module if available (Android only)
+      if (this.useNativeModule) {
+        console.log('🔄 [BundleUpdater] Using native module to load bundle');
+        await NativeBundleManager.loadBundle(bundlePath);
+        return true;
+      }
+
+      // Fallback: try OTABundleLoader if available
+      if (NativeModules.OTABundleLoader) {
+        await NativeModules.OTABundleLoader.loadBundle(bundlePath);
+        return true;
+      } else {
+        // Fallback: restart app with new bundle
+        console.warn('⚠️ [BundleUpdater] Native bundle loader not available. App restart required.');
+        return false;
+      }
+    } catch (error) {
+      console.error('Bundle load error:', error);
+      throw error;
+    }
+  }
+
+  async applyUpdate(bundlePath) {
+    try {
+      // Use native module if available
+      if (this.useNativeModule) {
+        console.log('✅ [BundleUpdater] Using native module to apply update');
+        // Install the bundle first
+        await NativeBundleManager.installBundle(bundlePath);
+        // Then load it
+        await NativeBundleManager.loadBundle(bundlePath);
+        return true;
+      }
+
+      // Fallback to file-based approach
+      const activeBundlePath = `${this.bundleCacheDir}/active.bundle`;
+      
+      // Copy downloaded bundle to active bundle
+      if (RNFS) {
+      await RNFS.copyFile(bundlePath, activeBundlePath);
+      }
+
+      // Load the new bundle
+      await this.loadBundle(activeBundlePath);
+
+      return true;
+    } catch (error) {
+      console.error('Apply update error:', error);
+      throw error;
+    }
+  }
+
+  getActiveBundlePath() {
+    return `${this.bundleCacheDir}/active.bundle`;
+  }
+
+  async clearOldBundles(keepVersion = null) {
+    try {
+      // Use native module if available
+      if (this.useNativeModule) {
+        await NativeBundleManager.clearBundles();
+        return;
+      }
+
+      // Fallback to file-based cleanup
+      if (RNFS) {
+      await this.ensureCacheDir();
+      const files = await RNFS.readDir(this.bundleCacheDir);
+      
+      for (const file of files) {
+        if (file.name !== 'active.bundle' && file.name !== `bundle-${keepVersion}.bundle`) {
+          await RNFS.unlink(file.path);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Clear old bundles error:', error);
+      // Don't throw - cleanup is not critical
+    }
+  }
+}
+
+export default BundleUpdater;
+

package/src/NativeBundleManager.js

@@ -0,0 +1,54 @@
+import { NativeModules, Platform } from 'react-native';
+
+const { OTANative } = NativeModules;
+
+class NativeBundleManager {
+  constructor() {
+    this.isAvailable = OTANative != null;
+  }
+
+  async downloadBundle(url, versionName) {
+    if (!this.isAvailable) {
+      throw new Error('OTANative module is not available');
+    }
+    return await OTANative.downloadBundle(url, versionName);
+  }
+
+  async installBundle(bundlePath) {
+    if (!this.isAvailable) {
+      throw new Error('OTANative module is not available');
+    }
+    return await OTANative.installBundle(bundlePath);
+  }
+
+  async loadBundle(bundlePath) {
+    if (!this.isAvailable) {
+      throw new Error('OTANative module is not available');
+    }
+    return await OTANative.loadBundle(bundlePath);
+  }
+
+  async getCurrentBundle() {
+    if (!this.isAvailable) {
+      return null;
+    }
+    return await OTANative.getCurrentBundle();
+  }
+
+  async clearBundles() {
+    if (!this.isAvailable) {
+      throw new Error('OTANative module is not available');
+    }
+    return await OTANative.clearBundles();
+  }
+
+  async getConfiguration() {
+    if (!this.isAvailable) {
+      return null;
+    }
+    return await OTANative.getConfiguration();
+  }
+}
+
+export default new NativeBundleManager();
+

package/src/NetworkMonitor.js

@@ -0,0 +1,88 @@
+// Optional import
+let NetInfo = null;
+try {
+  NetInfo = require('@react-native-community/netinfo');
+} catch (e) {
+  console.warn('@react-native-community/netinfo not available');
+}
+
+class NetworkMonitor {
+  constructor() {
+    this.isWifi = false;
+    this.isConnected = false;
+    this.listeners = [];
+    this.unsubscribe = null;
+  }
+
+  startMonitoring(callback) {
+    if (!NetInfo) {
+      console.warn('NetInfo not available, network monitoring disabled');
+      return;
+    }
+    
+    // Check initial state
+    NetInfo.fetch().then(state => {
+      this.updateState(state);
+      if (callback) callback(this.isWifi, this.isConnected);
+    }).catch(err => {
+      console.warn('NetInfo.fetch failed:', err);
+    });
+
+    // Subscribe to network state changes
+    this.unsubscribe = NetInfo.addEventListener(state => {
+      this.updateState(state);
+      this.listeners.forEach(listener => listener(this.isWifi, this.isConnected));
+      if (callback) callback(this.isWifi, this.isConnected);
+    });
+  }
+
+  updateState(state) {
+    this.isConnected = state.isConnected;
+    this.isWifi = state.type === 'wifi' && state.isConnected;
+  }
+
+  addListener(callback) {
+    this.listeners.push(callback);
+  }
+
+  removeListener(callback) {
+    this.listeners = this.listeners.filter(listener => listener !== callback);
+  }
+
+  stopMonitoring() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    this.listeners = [];
+  }
+
+  async checkWifiAsync() {
+    if (!NetInfo) {
+      return false;
+    }
+    try {
+      const state = await NetInfo.fetch();
+      return state.type === 'wifi' && state.isConnected;
+    } catch (err) {
+      console.warn('NetInfo.fetch failed:', err);
+      return false;
+    }
+  }
+
+  async checkConnectionAsync() {
+    if (!NetInfo) {
+      return false;
+    }
+    try {
+      const state = await NetInfo.fetch();
+      return state.isConnected;
+    } catch (err) {
+      console.warn('NetInfo.fetch failed:', err);
+      return false;
+    }
+  }
+}
+
+export default NetworkMonitor;
+

package/src/OTAUpdater.js

@@ -0,0 +1,310 @@
+import VersionChecker from './VersionChecker';
+import ApkDownloader from './ApkDownloader';
+import BundleUpdater from './BundleUpdater';
+import NetworkMonitor from './NetworkMonitor';
+
+class OTAUpdater {
+  constructor(config) {
+    this.config = {
+      apiUrl: config.apiUrl,
+      appId: config.appId,
+      apiKey: config.apiKey,
+      deviceId: config.deviceId,
+      currentVersionName: config.currentVersionName, // App version name (e.g., "1.0.0")
+      currentVersionCode: config.currentVersionCode, // App version code (e.g., 1)
+      checkInterval: config.checkInterval || 3600000, // 1 hour default
+      forceUpdateOnWifi: config.forceUpdateOnWifi || false,
+      autoDownloadOnWifi: config.autoDownloadOnWifi || false,
+      autoInstallApk: config.autoInstallApk !== undefined ? config.autoInstallApk : true, // Default: true (aggressive mode)
+      autoInstallOnWifi: config.autoInstallOnWifi || false, // Only auto-install when connected to WiFi
+      onUpdateAvailable: config.onUpdateAvailable || (() => {}),
+      onUpdateProgress: config.onUpdateProgress || (() => {}),
+      onUpdateComplete: config.onUpdateComplete || (() => {}),
+      onUpdateError: config.onUpdateError || (() => {}),
+    };
+
+    this.versionChecker = new VersionChecker(this.config);
+    this.networkMonitor = new NetworkMonitor();
+    this.apkDownloader = new ApkDownloader({
+      onProgress: this.handleDownloadProgress.bind(this),
+      onError: this.handleUpdateError.bind(this),
+      onSuccess: this.handleDownloadSuccess.bind(this),
+    });
+    this.bundleUpdater = new BundleUpdater({
+      onProgress: this.handleDownloadProgress.bind(this),
+      onError: this.handleUpdateError.bind(this),
+      onSuccess: this.handleDownloadSuccess.bind(this),
+    });
+
+    this.checkIntervalId = null;
+    this.isChecking = false;
+    this.currentUpdate = null;
+  }
+
+  start() {
+    // Start network monitoring
+    this.networkMonitor.startMonitoring((isWifi, isConnected) => {
+      if (isWifi && this.config.forceUpdateOnWifi) {
+        this.checkForUpdates();
+      }
+    });
+
+    // Initial check
+    this.checkForUpdates();
+
+    // Set up periodic checks
+    this.checkIntervalId = setInterval(() => {
+      if (!this.isChecking) {
+        this.checkForUpdates();
+      }
+    }, this.config.checkInterval);
+  }
+
+  stop() {
+    if (this.checkIntervalId) {
+      clearInterval(this.checkIntervalId);
+      this.checkIntervalId = null;
+    }
+    this.networkMonitor.stopMonitoring();
+  }
+
+  async checkForUpdates() {
+    if (this.isChecking) {
+      console.log('⚠️ [OTAUpdater] Update check already in progress, skipping...');
+      return;
+    }
+
+    try {
+      this.isChecking = true;
+      
+      // Check network connectivity before making API calls
+      console.log('🌐 [OTAUpdater] Checking network connectivity...');
+      const isConnected = await this.networkMonitor.checkConnectionAsync();
+      
+      if (!isConnected) {
+        console.warn('⚠️ [OTAUpdater] No internet connection. Update check skipped.');
+        const networkError = new Error('No internet connection available');
+        this.config.onUpdateError(networkError);
+        return;
+      }
+      
+      const isWifi = await this.networkMonitor.checkWifiAsync();
+      console.log(`✅ [OTAUpdater] Network connected (WiFi: ${isWifi ? 'Yes' : 'No'})`);
+      
+      const currentVersion = this.versionChecker.getCurrentVersion();
+      console.log('🔄 [OTAUpdater] Starting update check with version:', currentVersion);
+      const result = await this.versionChecker.checkForUpdates(currentVersion);
+
+      if (result.updateAvailable) {
+        this.currentUpdate = result.update;
+        this.config.onUpdateAvailable(result.update);
+
+        // Network already checked above, but re-check for WiFi status
+        const isWifi = await this.networkMonitor.checkWifiAsync();
+        const isConnected = await this.networkMonitor.checkConnectionAsync();
+
+        if (!isConnected) {
+          console.warn('⚠️ [OTAUpdater] Lost internet connection. Update check skipped.');
+          return;
+        }
+        
+        console.log(`📡 [OTAUpdater] Update available: ${result.update.versionName} (${result.update.updateType})`);
+
+        // Handle force update on WiFi
+        if (this.config.forceUpdateOnWifi && isWifi && result.update.updateType === 'major') {
+          await this.handleMajorUpdate(result.update, true);
+        } else if (result.update.updateType === 'major') {
+          // Major update - download and prompt
+          await this.handleMajorUpdate(result.update, false);
+        } else {
+          // Minor update - download bundle
+          if (isWifi && this.config.autoDownloadOnWifi) {
+            await this.handleMinorUpdate(result.update);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Update check error:', error);
+      this.config.onUpdateError(error);
+    } finally {
+      this.isChecking = false;
+    }
+  }
+
+  async handleMajorUpdate(update, force = false) {
+    try {
+      // Report status: downloading
+      await this.versionChecker.reportUpdateStatus(
+        'downloading',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'major'
+      );
+
+      // Download APK
+      const filePath = await this.apkDownloader.downloadApk(
+        update.downloadUrl,
+        update.versionName
+      );
+
+      if (force) {
+        // Force update - always auto-install
+        this.apkDownloader.showForceUpdateAlert();
+        await this.apkDownloader.installApk(filePath);
+      } else if (this.config.autoInstallApk) {
+        // Check WiFi requirement if autoInstallOnWifi is enabled
+        if (this.config.autoInstallOnWifi) {
+          const isWifi = await this.networkMonitor.checkWifiAsync();
+          if (isWifi) {
+            console.log('🚀 [OTAUpdater] Auto-installing APK (WiFi connected)...');
+            try {
+              await this.apkDownloader.installApk(filePath);
+            } catch (installError) {
+              console.error('❌ [OTAUpdater] Auto-install failed, falling back to prompt:', installError);
+              // Fall back to showing prompt if auto-install fails
+              this.apkDownloader.showInstallPrompt(
+                filePath,
+                update.versionName,
+                update.releaseNotes
+              );
+            }
+          } else {
+            // Not on WiFi - show prompt instead
+            console.log('⚠️ [OTAUpdater] Not on WiFi, showing install prompt...');
+            this.apkDownloader.showInstallPrompt(
+              filePath,
+              update.versionName,
+              update.releaseNotes
+            );
+          }
+        } else {
+          // Auto-install regardless of network type
+          console.log('🚀 [OTAUpdater] Auto-installing APK...');
+          try {
+            await this.apkDownloader.installApk(filePath);
+          } catch (installError) {
+            console.error('❌ [OTAUpdater] Auto-install failed, falling back to prompt:', installError);
+            // Fall back to showing prompt if auto-install fails
+            this.apkDownloader.showInstallPrompt(
+              filePath,
+              update.versionName,
+              update.releaseNotes
+            );
+          }
+        }
+      } else {
+        // Default behavior - show prompt
+        this.apkDownloader.showInstallPrompt(
+          filePath,
+          update.versionName,
+          update.releaseNotes
+        );
+      }
+
+      // Report status: completed
+      await this.versionChecker.reportUpdateStatus(
+        'completed',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'major'
+      );
+
+      this.config.onUpdateComplete(update);
+    } catch (error) {
+      console.error('Major update error:', error);
+      await this.versionChecker.reportUpdateStatus(
+        'failed',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'major',
+        error.message
+      );
+      this.config.onUpdateError(error);
+    }
+  }
+
+  async handleMinorUpdate(update) {
+    try {
+      // Minor updates require bundle download URL from backend
+      // The backend now provides bundleUrl in the update response
+      
+      if (!update.bundleUrl) {
+        console.warn('⚠️ [OTAUpdater] Bundle URL not provided for minor update');
+        console.warn('   Update object:', update);
+        return;
+      }
+
+      console.log(`📦 [OTAUpdater] Starting minor update: ${update.versionName}`);
+      console.log(`   Bundle URL: ${update.bundleUrl}`);
+
+      // Report status: downloading
+      await this.versionChecker.reportUpdateStatus(
+        'downloading',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'minor'
+      );
+
+      // Download bundle
+      const bundlePath = await this.bundleUpdater.downloadBundle(
+        update.bundleUrl,
+        update.versionName
+      );
+
+      console.log(`✅ [OTAUpdater] Bundle downloaded: ${bundlePath}`);
+
+      // Apply update
+      await this.bundleUpdater.applyUpdate(bundlePath);
+
+      console.log(`✅ [OTAUpdater] Bundle update applied successfully`);
+
+      // Clean up old bundles
+      await this.bundleUpdater.clearOldBundles(update.versionName);
+
+      // Report status: completed
+      await this.versionChecker.reportUpdateStatus(
+        'completed',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'minor'
+      );
+
+      this.config.onUpdateComplete(update);
+    } catch (error) {
+      console.error('❌ [OTAUpdater] Minor update error:', error);
+      await this.versionChecker.reportUpdateStatus(
+        'failed',
+        this.versionChecker.getCurrentVersion().versionName,
+        update.versionName,
+        'minor',
+        error.message
+      );
+      this.config.onUpdateError(error);
+    }
+  }
+
+  handleDownloadProgress(progress, bytesWritten, contentLength) {
+    this.config.onUpdateProgress({
+      progress,
+      bytesWritten,
+      contentLength,
+      type: this.currentUpdate?.updateType || 'unknown',
+    });
+  }
+
+  handleDownloadSuccess(filePath) {
+    console.log('Download successful:', filePath);
+  }
+
+  handleUpdateError(error) {
+    this.config.onUpdateError(error);
+  }
+
+  // Manual check method
+  async manualCheck() {
+    await this.checkForUpdates();
+  }
+}
+
+export default OTAUpdater;
+