react-native-update 10.37.0 → 10.37.2

package/README.md

@@ -11,7 +11,7 @@
 ### 优势
 
 1. 对中国用户使用阿里云高速 CDN 分发，对比其他服务器在国外的热更新服务，分发更稳定，更新成功率极高。对国外用户则智能分流至 cloudflare，同样享受高速更新服务。
-2. 基于 bsdiff/hdiff 算法创建的**超小更新包**，通常版本迭代后在几十 KB 级别（其他全量热更新服务所需流量通常在几十 MB 级别）。
+2. 基于 bsdiff/hdiff 算法创建的**超小更新包**，通常版本迭代后在几十至几百 KB 级别（其他全量热更新服务所需流量通常在几十 MB 级别）。
 3. 始终跟进 RN 最新正式版本，第一时间提供支持。支持 hermes 字节码格式。支持新架构（注：安卓 0.73.0 ~ 0.76.0 的新架构因官方 bug 不支持，0.73 以下或 0.76.1 以上的新架构可用）。
 4. 跨越多个版本进行更新时，只需要下载**一个更新包**，不需要逐版本依次更新。
 5. 命令行工具 & 网页双端管理，版本发布过程简单便捷，完全可以集成 CI。
@@ -24,7 +24,7 @@
 | 对比维度 | react-native-update | expo-update | react-native-code-push |
 |---------|---------------------|-------------|------------------------|
 | **价格/成本** | 提供免费额度，多级梯度付费（最低约 66 元/月），流量不单独计费 | 提供免费额度，多级梯度付费（最低约 136 元/月），超出流量额外计费 | ❌ **已停运**（Microsoft App Center 已于 2025 年 3 月 31 日停止服务） |
-| **更新包大小** | ⭐⭐⭐⭐⭐ 几十 KB（增量更新） | ⭐⭐⭐ 全量更新（通常几十 MB） | ❌ **已停运** |
+| **更新包大小** | ⭐⭐⭐⭐⭐ 几十至几百 KB（增量更新） | ⭐⭐⭐ 全量更新（通常几十 MB） | ❌ **已停运** |
 | **中国地区访问速度** | ⭐⭐⭐⭐⭐ 阿里云 CDN，速度极快 | ⭐⭐ 国外服务器，可能较慢 | ❌ **已停运** |
 | **iOS 支持** | ✅ 支持 | ✅ 支持 | ❌ **已停运** |
 | **Android 支持** | ✅ 支持 | ✅ 支持 | ❌ **已停运** |

package/android/src/main/java/cn/reactnative/modules/update/UpdateModuleImpl.java

@@ -134,13 +134,21 @@ public class UpdateModuleImpl {
         }
     }
 
-    public static void reloadUpdate(final UpdateContext updateContext,final ReactApplicationContext mContext, final ReadableMap options, final Promise promise) {
+    public static void reloadUpdate(final UpdateContext updateContext, final ReactApplicationContext mContext, final ReadableMap options, final Promise promise) {
         final String hash = options.getString("hash");
+        restartApp(updateContext, mContext, hash, promise);
+    }
+
+
+    public static void restartApp(final UpdateContext updateContext, final ReactApplicationContext mContext, final String hash, final Promise promise) {
         UiThreadUtil.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-
-                updateContext.switchVersion(hash);
+                // 如果提供了 hash，则切换版本
+                if (hash != null && updateContext != null) {
+                    updateContext.switchVersion(hash);
+                }
+                
                 final Context application = mContext.getApplicationContext();
                 JSBundleLoader loader = JSBundleLoader.createFileLoader(UpdateContext.getBundleUrl(application));
                 try {
@@ -166,6 +174,7 @@ public class UpdateModuleImpl {
                 } catch (Throwable err) {
                     final Activity currentActivity = mContext.getCurrentActivity();
                     if (currentActivity == null) {
+                        promise.reject(err);
                         return;
                     }
                     try {
@@ -203,6 +212,7 @@ public class UpdateModuleImpl {
 
                         // Invoke the reload method with a reason
                         reloadMethod.invoke(reactHost, "react-native-update");
+                        promise.resolve(true);
                     } catch (Throwable e) {
                         currentActivity.runOnUiThread(new Runnable() {
                             @Override
@@ -210,42 +220,17 @@ public class UpdateModuleImpl {
                                 currentActivity.recreate();
                             }
                         });
+                        promise.resolve(true);
                     }
                 }
-                promise.resolve(true);
             }
         });
     }
 
+
     public static void restartApp(final ReactApplicationContext mContext, final Promise promise) {
-          UiThreadUtil.runOnUiThread(new Runnable() {
-              @Override
-              public void run() {
-                  try {
-                      final Context application = mContext.getApplicationContext();
-                      ReactInstanceManager instanceManager = ((ReactApplication) application).getReactNativeHost().getReactInstanceManager();
-
-                      instanceManager.recreateReactContextInBackground();
-                      promise.resolve(true);
-
-                  } catch (Throwable err) {
-                      promise.reject("restartApp failed: "+err.getMessage());
-                      Log.e("pushy", "restartApp failed", err);
-
-                      final Activity currentActivity = mContext.getCurrentActivity();
-                      if (currentActivity == null) {
-                          return;
-                      }
-                      currentActivity.runOnUiThread(new Runnable() {
-                          @Override
-                          public void run() {
-                              currentActivity.recreate();
-                          }
-                      });
-                  }
-              }
-          });
-      }
+        restartApp(null, mContext, null, promise);
+    }
 
     public static void setNeedUpdate(final UpdateContext updateContext, final ReadableMap options, final Promise promise) {
         final String hash = options.getString("hash");
@@ -320,3 +305,4 @@ public class UpdateModuleImpl {
     }
 
 }
+

package/android/src/newarch/cn/reactnative/modules/update/UpdateModule.java

@@ -104,27 +104,27 @@ public class UpdateModule extends NativePushySpec {
 
     @Override
     public void downloadPatchFromPpk(ReadableMap options, final Promise promise) {
-        UpdateModuleImpl.downloadPatchFromPpk(updateContext,options,promise);
+        UpdateModuleImpl.downloadPatchFromPpk(updateContext, options, promise);
     }
 
     @Override
     public void reloadUpdate(ReadableMap options,Promise promise) {
-        UpdateModuleImpl.reloadUpdate(updateContext, mContext, options,promise);
+        UpdateModuleImpl.reloadUpdate(updateContext, mContext, options, promise);
     }
 
     @Override
     public void restartApp(Promise promise) {
-        UpdateModuleImpl.restartApp(mContext, promise);
+        UpdateModuleImpl.restartApp(updateContext, mContext, null, promise);
     }
 
     @Override
     public void setNeedUpdate(ReadableMap options,Promise promise) {
-        UpdateModuleImpl.setNeedUpdate(updateContext, options,promise);
+        UpdateModuleImpl.setNeedUpdate(updateContext, options, promise);
     }
 
     @Override
     public void markSuccess(Promise promise) {
-        UpdateModuleImpl.markSuccess(updateContext,promise);
+        UpdateModuleImpl.markSuccess(updateContext, promise);
     }
 
     @Override

package/harmony/pushy/hvigor-plugin.ts

@@ -4,36 +4,31 @@ import path from 'path';
 export function reactNativeUpdatePlugin() {
   return {
     pluginId: 'reactNativeUpdatePlugin',
-    apply(node) {
-      node.registerTask({
-        name: 'reactNativeUpdatePlugin',
-        run: () => {
-          const cwd = process.cwd();
-          const metaFilePath = path.resolve(
-            cwd,
-            'entry/src/main/resources/rawfile/meta.json',
-          );
-          fs.mkdirSync(path.dirname(metaFilePath), { recursive: true });
+    apply(_node) {
+      const cwd = process.cwd();
+      const metaFilePath = path.resolve(
+        cwd,
+        'entry/src/main/resources/rawfile/meta.json',
+      );
+      fs.mkdirSync(path.dirname(metaFilePath), { recursive: true });
 
-          const moduleJsonPath = path.resolve(cwd, 'AppScope/app.json5');
-          let versionName = '';
-          if (fs.existsSync(moduleJsonPath)) {
-            const content = fs.readFileSync(moduleJsonPath, 'utf-8');
-            const match = content.match(
-              /(?:"versionName"|versionName):\s*["']([^"']+)["']/,
-            );
-            versionName = match?.[1] || '';
-          }
+      const moduleJsonPath = path.resolve(cwd, 'AppScope/app.json5');
+      let versionName = '';
+      if (fs.existsSync(moduleJsonPath)) {
+        const content = fs.readFileSync(moduleJsonPath, 'utf-8');
+        const match = content.match(
+          /(?:"versionName"|versionName):\s*["']([^"']+)["']/,
+        );
+        versionName = match?.[1] || '';
+      }
 
-          const metaContent = {
-            pushy_build_time: new Date().toISOString(),
-            versionName,
-          };
+      const metaContent = {
+        pushy_build_time: Date.now(),
+        versionName,
+      };
 
-          fs.writeFileSync(metaFilePath, JSON.stringify(metaContent, null, 2));
-          console.log(`Build time written to ${metaFilePath}`);
-        },
-      });
+      fs.writeFileSync(metaFilePath, JSON.stringify(metaContent, null, 2));
+      console.log(`Build time written to ${metaFilePath}`);
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.37.0",
+  "version": "10.37.2",
   "description": "react-native hot update",
   "main": "src/index",
   "scripts": {

package/scripts/bundle-metadata-plugin.js

@@ -0,0 +1,184 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+console.log(`[Bundle Metadata] Project root: ${PROJECT_ROOT}`);
+
+function calculateContentHash(bundleCode) {
+  const hash = crypto.createHash('sha256');
+  hash.update(bundleCode, 'utf8');
+  return hash.digest('hex');
+}
+
+function generateMetadataInjection(contentHash) {
+  return `// Auto-injected bundle metadata by Metro plugin
+  var __BUNDLE_METADATA__ = {
+    contentHash: '${contentHash}'
+  };
+`;
+}
+
+function generateMetadataComment(contentHash) {
+  return `\n//# BUNDLE_METADATA ${JSON.stringify({
+  contentHash
+})}`;
+}
+
+function setupSingleHermesc(hermescPath, locationName) {
+  const hermescDir = path.dirname(hermescPath);
+  const backupHermescPath = path.join(hermescDir, '_hermesc');
+  const wrapperSourcePath = path.join(__dirname, 'hermesc-wrapper.js');
+
+  if (fs.existsSync(backupHermescPath)) {
+    console.log(`⏭️  [Hermesc Setup] ${locationName} already configured, skipping...`);
+    return true;
+  }
+
+  if (!fs.existsSync(hermescPath)) {
+    console.log(`ℹ️  [Hermesc Setup] ${locationName} hermesc not found at: ${hermescPath}`);
+    return false;
+  }
+
+  if (!fs.existsSync(wrapperSourcePath)) {
+    console.error(`❌ [Hermesc Setup] Wrapper script not found at: ${wrapperSourcePath}`);
+    return false;
+  }
+
+  try {
+    console.log(`🔧 [Hermesc Setup] Setting up hermesc wrapper for ${locationName}...`);
+
+    fs.renameSync(hermescPath, backupHermescPath);
+    console.log(`✅ [Hermesc Setup] ${locationName}: Renamed hermesc -> _hermesc`);
+
+    const shellScript = `#!/bin/bash
+# Hermesc wrapper script - auto-generated
+# This script calls the Node.js wrapper which handles post-processing
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+WRAPPER_SCRIPT="${wrapperSourcePath}"
+
+find_node() {
+  if command -v node >/dev/null 2>&1; then
+    command -v node
+    return 0
+  fi
+
+  local NODE_PATHS=(
+    "/usr/local/bin/node"
+    "/opt/homebrew/bin/node"
+    "$HOME/.nvm/versions/node/$(ls -t "$HOME/.nvm/versions/node" 2>/dev/null | head -1)/bin/node"
+    "/usr/bin/node"
+  )
+
+  for node_path in "\${NODE_PATHS[@]}"; do
+    if [ -x "$node_path" ]; then
+      echo "$node_path"
+      return 0
+    fi
+  done
+
+  echo "Error: node executable not found" >&2
+  echo "Please ensure Node.js is installed and accessible" >&2
+  exit 1
+}
+
+NODE_BIN=$(find_node)
+exec "$NODE_BIN" "$WRAPPER_SCRIPT" "$@"
+`;
+
+    fs.writeFileSync(hermescPath, shellScript, { mode: 0o755 });
+    console.log(`✅ [Hermesc Setup] ${locationName}: Created hermesc wrapper shell script`);
+
+    console.log(`🎉 [Hermesc Setup] ${locationName} configured successfully!`);
+    console.log(`📋 [Hermesc Setup] ${locationName} details:`);
+    console.log(`   - Original: ${backupHermescPath}`);
+    console.log(`   - Wrapper: ${hermescPath}`);
+    console.log(`   - Handler: ${wrapperSourcePath}`);
+
+    return true;
+  } catch (error) {
+    console.error(`❌ [Hermesc Setup] Failed to setup hermesc wrapper for ${locationName}:`, error);
+
+    if (fs.existsSync(backupHermescPath) && !fs.existsSync(hermescPath)) {
+      try {
+        fs.renameSync(backupHermescPath, hermescPath);
+        console.log(`🔄 [Hermesc Setup] ${locationName}: Rolled back changes`);
+      } catch (rollbackError) {
+        console.error(`❌ [Hermesc Setup] ${locationName}: Rollback failed:`, rollbackError);
+      }
+    }
+
+    return false;
+  }
+}
+
+function setupHermescWrapper() {
+  const wrapperSourcePath = path.join(__dirname, 'hermesc-wrapper.js');
+
+  if (!fs.existsSync(wrapperSourcePath)) {
+    console.error(`❌ [Hermesc Setup] Wrapper script not found at: ${wrapperSourcePath}`);
+    return;
+  }
+
+  try {
+    fs.chmodSync(wrapperSourcePath, 0o755);
+  } catch (error) {
+    console.error('❌ [Hermesc Setup] Failed to set execute permissions on wrapper:', error);
+  }
+
+  console.log('🔧 [Hermesc Setup] Starting hermesc wrapper setup...');
+
+  const hermescLocations = [
+    {
+      path: path.join(PROJECT_ROOT, 'node_modules/react-native/sdks/hermesc/osx-bin/hermesc'),
+      name: 'Node Modules'
+    },
+    {
+      path: path.join(PROJECT_ROOT, 'ios/Pods/hermes-engine/destroot/bin/hermesc'),
+      name: 'iOS Pods'
+    }
+  ];
+
+  let successCount = 0;
+  let totalProcessed = 0;
+
+  for (const location of hermescLocations) {
+    const success = setupSingleHermesc(location.path, location.name);
+    if (success) {
+      successCount++;
+    }
+    totalProcessed++;
+  }
+
+  console.log(`\n📊 [Hermesc Setup] Summary: ${successCount}/${totalProcessed} locations configured successfully`);
+}
+
+function metadataSerializer(entryPoint, preModules, graph, options) {
+  setupHermescWrapper();
+  const baseJSBundle = require('metro/src/DeltaBundler/Serializers/baseJSBundle');
+  const bundleToString = require('metro/src/lib/bundleToString');
+  const bundle = baseJSBundle(entryPoint, preModules, graph, options);
+  const { code: bundleCode } = bundleToString(bundle);
+  const contentHash = calculateContentHash(bundleCode);
+  const metadataInjection = generateMetadataInjection(contentHash);
+  const metadataComment = generateMetadataComment(contentHash);
+  const hashFilePath = path.join(PROJECT_ROOT, 'bundle-hash.json');
+
+  try {
+    const hashData = {
+      contentHash,
+      timestamp: new Date().toISOString(),
+    };
+    fs.writeFileSync(hashFilePath, JSON.stringify(hashData, null, 2));
+    console.log(`✅ [Metro] Saved hash to: ${hashFilePath}`);
+    console.log(`🔐 [Metro] Hash: ${contentHash.slice(0, 16)}...`);
+  } catch (error) {
+    console.error('❌ [Metro] Failed to save hash file:', error);
+  }
+
+  return bundleCode + metadataInjection + metadataComment;
+}
+
+module.exports = {
+  metadataSerializer,
+};

package/scripts/hermesc-wrapper.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+const realHermescPath = path.join(PROJECT_ROOT, 'node_modules/react-native/sdks/hermesc/osx-bin/_hermesc');
+const args = process.argv.slice(2);
+
+console.log(`[Hermesc Wrapper] Executing Hermes compilation...`);
+console.log(`[Hermesc Wrapper] Args:`, args.join(' '));
+
+const isCompileOperation = args.includes('-emit-binary');
+let outputFile = null;
+
+const outIndex = args.indexOf('-out');
+if (outIndex !== -1 && outIndex + 1 < args.length) {
+  outputFile = args[outIndex + 1];
+}
+
+const hermesc = spawn(realHermescPath, args, {
+  stdio: 'inherit',
+  env: process.env
+});
+
+hermesc.on('error', (error) => {
+  console.error(`[Hermesc Wrapper] ❌ Failed to start hermesc:`, error);
+  process.exit(1);
+});
+
+hermesc.on('close', (code) => {
+  console.log(`[Hermesc Wrapper] Hermes compilation completed with code: ${code}`);
+
+  if (code === 0 && isCompileOperation && outputFile) {
+    console.log(`[Hermesc Wrapper] 🔄 Post-processing HBC file: ${outputFile}`);
+
+    setTimeout(() => {
+      processHBCFile(outputFile);
+    }, 500);
+  } else {
+    process.exit(code);
+  }
+});
+
+function processHBCFile(hbcFilePath) {
+  const hashFilePath = path.join(PROJECT_ROOT, 'bundle-hash.json');
+
+  if (!fs.existsSync(hashFilePath)) {
+    console.warn(`[Hermesc Wrapper] ⚠️  Hash file not found: ${hashFilePath}`);
+    console.warn(`[Hermesc Wrapper] Skipping metadata injection.`);
+    process.exit(0);
+    return;
+  }
+
+  if (!fs.existsSync(hbcFilePath)) {
+    console.warn(`[Hermesc Wrapper] ⚠️  HBC file not found: ${hbcFilePath}`);
+    console.warn(`[Hermesc Wrapper] Skipping metadata injection.`);
+    process.exit(0);
+    return;
+  }
+
+  try {
+    const hashData = JSON.parse(fs.readFileSync(hashFilePath, 'utf8'));
+    const { contentHash } = hashData;
+
+    console.log(`[Hermesc Wrapper] 📝 Injecting metadata into HBC...`);
+    console.log(`[Hermesc Wrapper] Hash: ${contentHash.slice(0, 16)}...`);
+
+    const hbcBuffer = fs.readFileSync(hbcFilePath);
+
+    const metadata = { contentHash };
+    const metadataJson = JSON.stringify(metadata);
+
+    const MAGIC = Buffer.from('RNUPDATE', 'utf8');
+    const jsonBuffer = Buffer.from(metadataJson, 'utf8');
+    const lengthBuffer = Buffer.alloc(4);
+    lengthBuffer.writeUInt32LE(jsonBuffer.length);
+
+    const finalBuffer = Buffer.concat([
+      hbcBuffer,
+      MAGIC,
+      jsonBuffer,
+      lengthBuffer,
+      MAGIC,
+    ]);
+
+    fs.writeFileSync(hbcFilePath, finalBuffer);
+
+    console.log(`[Hermesc Wrapper] ✅ Successfully injected metadata into: ${hbcFilePath}`);
+    console.log(`[Hermesc Wrapper] 🧹 Cleaning up hash file...`);
+
+    process.exit(0);
+  } catch (error) {
+    console.error(`[Hermesc Wrapper] ❌ Failed to process HBC file:`, error);
+    process.exit(1);
+  }
+}