rn-update 1.0.0

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

@@ -0,0 +1,70 @@
+/**
+ * [INPUT]: 依赖 ReactApplicationContext、DeviceEventManagerModule、WritableMap 与新旧 RN 实例存活探测
+ * [OUTPUT]: 对内提供 register 和 sendEvent，将下载进度安全发送到 RCTPaktaDownloadProgress 通道
+ * [POS]: Android 原生到 JS 的事件桥，以弱引用和销毁竞态保护避免更新触发重载时崩溃
+ */
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.WritableMap;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Method;
+
+final class UpdateEventEmitter {
+    private static WeakReference<ReactApplicationContext> reactContextRef =
+        new WeakReference<ReactApplicationContext>(null);
+
+    private UpdateEventEmitter() {
+    }
+
+    static synchronized void register(ReactApplicationContext reactContext) {
+        reactContextRef = new WeakReference<ReactApplicationContext>(reactContext);
+    }
+
+    @Nullable
+    private static synchronized ReactApplicationContext getReactContext() {
+        return reactContextRef.get();
+    }
+
+    static void sendEvent(String eventName, WritableMap params) {
+        ReactApplicationContext reactContext = getReactContext();
+        if (reactContext == null || !hasActiveInstance(reactContext)) {
+            return;
+        }
+
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+        } catch (RuntimeException e) {
+            // The instance can be torn down between the check above and the
+            // emit (this SDK itself triggers reloads); sendEvent runs on the
+            // main thread, so a throw here would crash the app for a lost
+            // progress tick.
+            Log.w("pakta", "sendEvent " + eventName + " failed: " + e.getMessage());
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private static boolean hasActiveInstance(ReactApplicationContext reactContext) {
+        try {
+            // Use reflection for hasActiveReactInstance() because older RN versions (<0.68)
+            // don't have this method in the class signature at compile time.
+            Method method = reactContext.getClass().getMethod("hasActiveReactInstance");
+            Object result = method.invoke(reactContext);
+            if (result instanceof Boolean) {
+                return (Boolean) result;
+            }
+        } catch (Throwable ignored) {
+            // RN < 0.68 has no hasActiveReactInstance(); fall back for old peers.
+        }
+        try {
+            return reactContext.hasActiveCatalystInstance();
+        } catch (Throwable ignored) {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,110 @@
+/**
+ * [INPUT]: 依赖 java.io 文件/流 API 与更新目录调用方给出的受控路径
+ * [OUTPUT]: 对内提供目录确保、递归删除、文件复制和输入流落盘原语
+ * [POS]: Android 更新文件 IO 基础层，被 DownloadTask 与 BundledResourceCopier 复用，集中失败语义
+ */
+package cn.reactnative.modules.update;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+final class UpdateFileUtils {
+    private static final int BUFFER_SIZE = 8192;
+
+    private UpdateFileUtils() {
+    }
+
+    // Server-provided identifiers (hash/originHash/fileName) become child
+    // names under the update root; anything that could resolve outside of it
+    // (path separators, "..", ".") must be rejected before touching the
+    // filesystem.
+    static boolean isSafePathComponent(String name) {
+        return name != null
+                && !name.isEmpty()
+                && !name.equals(".")
+                && !name.equals("..")
+                && !name.contains("/")
+                && !name.contains("\\")
+                && name.indexOf('\0') < 0;
+    }
+
+    static void ensureDirectory(File directory) throws IOException {
+        if (!directory.exists() && !directory.mkdirs() && !directory.exists()) {
+            throw new IOException("Failed to create directory: " + directory);
+        }
+    }
+
+    static void ensureParentDirectory(File file) throws IOException {
+        File parent = file.getParentFile();
+        if (parent != null) {
+            ensureDirectory(parent);
+        }
+    }
+
+    static void removeDirectory(File file) throws IOException {
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            if (files != null) {
+                for (File child : files) {
+                    String name = child.getName();
+                    if (name.equals(".") || name.equals("..")) {
+                        continue;
+                    }
+                    removeDirectory(child);
+                }
+            }
+        }
+        if (file.exists() && !file.delete()) {
+            throw new IOException("Failed to delete " + file);
+        }
+    }
+
+    /** Streaming SHA-256 of a file, lowercase hex. */
+    static String sha256Hex(File file) throws IOException {
+        try (InputStream in = new FileInputStream(file)) {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] buffer = new byte[64 * 1024];
+            int read;
+            while ((read = in.read(buffer)) != -1) {
+                md.update(buffer, 0, read);
+            }
+            byte[] digest = md.digest();
+            StringBuilder hex = new StringBuilder(digest.length * 2);
+            for (byte b : digest) {
+                hex.append(Character.forDigit((b >> 4) & 0xf, 16));
+                hex.append(Character.forDigit(b & 0xf, 16));
+            }
+            return hex.toString();
+        } catch (java.security.NoSuchAlgorithmException e) {
+            throw new IOException("SHA-256 unavailable", e);
+        }
+    }
+
+    static void copyFile(File from, File to) throws IOException {
+        ensureParentDirectory(to);
+        try (
+            InputStream in = new FileInputStream(from);
+            FileOutputStream out = new FileOutputStream(to)
+        ) {
+            copy(in, out);
+        }
+    }
+
+    static void copyInputStreamToFile(InputStream input, File destination) throws IOException {
+        ensureParentDirectory(destination);
+        try (InputStream in = input; FileOutputStream out = new FileOutputStream(destination)) {
+            copy(in, out);
+        }
+    }
+
+    private static void copy(InputStream in, FileOutputStream out) throws IOException {
+        byte[] buffer = new byte[BUFFER_SIZE];
+        int count;
+        while ((count = in.read(buffer)) != -1) {
+            out.write(buffer, 0, count);
+        }
+    }
+}

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

@@ -0,0 +1,403 @@
+/**
+ * [INPUT]: 依赖 UpdateContext、ReadableMap/Promise、UpdateModuleSupport、StateSerialRunner、UiThreadRunner 与 ReactReloadManager
+ * [OUTPUT]: 对外提供新旧架构共用的下载、安装、切包、重载、版本绑定成功确认、重置、配置、缓存和本地版本信息静态命令
+ * [POS]: Android 原生模块应用服务门面，统一参数提取、线程归属与稳定错误码，防止两套桥实现行为漂移
+ */
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import java.util.HashMap;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+/**
+ * Everything the "Pakta" native module does, independent of the bridge it is
+ * registered with. The old-architecture and new-architecture UpdateModule
+ * classes are thin wrappers that only carry their annotations / spec
+ * overrides and forward here, so the two cannot drift apart.
+ */
+public class UpdateModuleImpl {
+
+    public static final String NAME = "Pakta";
+
+    private final ReactApplicationContext reactContext;
+    private final UpdateContext updateContext;
+
+    public UpdateModuleImpl(ReactApplicationContext reactContext) {
+        this(reactContext, UpdateContext.getInstance(reactContext));
+    }
+
+    public UpdateModuleImpl(ReactApplicationContext reactContext, UpdateContext updateContext) {
+        this.reactContext = reactContext;
+        this.updateContext = updateContext;
+        UpdateEventEmitter.register(reactContext);
+    }
+
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<String, Object>();
+        constants.put("downloadRootDir", updateContext.getRootDir());
+        constants.put("packageVersion", updateContext.getPackageVersion());
+
+        String currentVersion = updateContext.getCurrentVersion();
+        constants.put("currentVersion", currentVersion);
+        constants.put("currentVersionInfo", updateContext.getKv("hash_" + currentVersion));
+        constants.put("currentBundleSha256", updateContext.currentBundleSha256(currentVersion));
+        constants.put("buildTime", updateContext.getBuildTime());
+        constants.put("channel", updateContext.getChannel());
+        constants.put("isUsingBundleUrl", updateContext.getIsUsingBundleUrl());
+
+        // Both one-shot markers are consumed in a single commit: under
+        // TurboModules this runs synchronously on the JS thread.
+        UpdateContext.LaunchMarkers markers = updateContext.consumeLaunchMarkers();
+        constants.put("isFirstTime", markers.isFirstTime);
+        constants.put("rolledBackVersion", markers.rolledBackVersion);
+
+        constants.put("uuid", updateContext.getKv("uuid"));
+        int supportedDiffVersion = 0;
+        try {
+            supportedDiffVersion = NativeUpdateCore.supportedDiffVersion();
+        } catch (UnsatisfiedLinkError e) {
+            // A mismatched librnupdate.so (stale manual copy / build cache)
+            // must not crash startup via getConstants; 0 simply means "no v2
+            // diff track" and the server degrades gracefully.
+            Log.e("pakta", "supportedDiffVersion missing from librnupdate.so", e);
+        }
+        constants.put("supportedDiffVersion", supportedDiffVersion);
+        return constants;
+    }
+
+    /**
+     * Reads a required string option. A module call runs on the native
+     * modules thread, where anything thrown (a missing key, a wrong type)
+     * reaches the bridge's exception handler and kills the app, so a bad
+     * argument has to come back as an INVALID_OPTIONS rejection instead
+     * (CODE_AUDIT 2.11). Returns null after rejecting.
+     */
+    @Nullable
+    private static String readRequiredString(
+        @Nullable ReadableMap options,
+        String key,
+        Promise promise
+    ) {
+        String value = null;
+        try {
+            if (options != null && options.hasKey(key) && !options.isNull(key)) {
+                value = options.getString(key);
+            }
+        } catch (RuntimeException e) {
+            // Wrong type: treated like a missing key below.
+        }
+        return requireNonEmpty(value, "options." + key, promise);
+    }
+
+    /** Same contract for a plain string argument. */
+    @Nullable
+    private static String requireNonEmpty(
+        @Nullable String value,
+        String name,
+        Promise promise
+    ) {
+        if (value == null || value.isEmpty()) {
+            promise.reject(ErrorCodes.INVALID_OPTIONS, name + " must be a non-empty string");
+            return null;
+        }
+        return value;
+    }
+
+    private static boolean isValidHashInfo(@Nullable String json) {
+        if (json == null) {
+            return false;
+        }
+        try {
+            return new JSONTokener(json).nextValue() instanceof JSONObject;
+        } catch (JSONException e) {
+            return false;
+        }
+    }
+
+    private static UpdateContext.DownloadFileListener downloadListener(final Promise promise) {
+        return new UpdateContext.DownloadFileListener() {
+            @Override
+            public void onDownloadCompleted(DownloadTaskParams params) {
+                promise.resolve(null);
+            }
+
+            @Override
+            public void onDownloadFailed(Throwable error) {
+                promise.reject(downloadErrorCode(error), error);
+            }
+        };
+    }
+
+    // Post-download failures (unzip / hdiff / resource copy, incl. copiesCrc
+    // verification) reject as PATCH_FAILED so JS-side telemetry can separate
+    // patch health from network health; a local refusal (reinstalling the
+    // running version in place) as FILE_OPERATION_FAILED. DownloadTask
+    // classifies them.
+    private static String downloadErrorCode(Throwable error) {
+        if (error instanceof PatchFailedException) {
+            return ErrorCodes.PATCH_FAILED;
+        }
+        if (error instanceof FileOperationException) {
+            return ErrorCodes.FILE_OPERATION_FAILED;
+        }
+        return ErrorCodes.DOWNLOAD_FAILED;
+    }
+
+    public void downloadFullUpdate(final ReadableMap options, final Promise promise) {
+        String url = readRequiredString(options, "updateUrl", promise);
+        if (url == null) {
+            return;
+        }
+        String hash = readRequiredString(options, "hash", promise);
+        if (hash == null) {
+            return;
+        }
+        updateContext.downloadFullUpdate(url, hash, downloadListener(promise));
+    }
+
+    public void downloadAndInstallApk(final ReadableMap options, final Promise promise) {
+        // Every failure of this path — a missing REQUEST_INSTALL_PACKAGES
+        // declaration above all — has to come back as a promise rejection,
+        // never as an exception on the native modules thread.
+        try {
+            final String url = readRequiredString(options, "url", promise);
+            if (url == null) {
+                return;
+            }
+            String hash = readRequiredString(options, "hash", promise);
+            if (hash == null) {
+                return;
+            }
+            String target = readRequiredString(options, "target", promise);
+            if (target == null) {
+                return;
+            }
+            if (!HttpUtils.isHttpsUrl(url)) {
+                // Installing an APK is code execution and nothing verifies
+                // its bytes yet (CODE_AUDIT 2.6): TLS is the only thing
+                // standing between the server and the device, so a plaintext
+                // URL is refused outright.
+                promise.reject(ErrorCodes.INVALID_OPTIONS, "APK url must use https: " + url);
+                return;
+            }
+            if (!ApkInstaller.ensureInstallPermission(reactContext, promise)) {
+                return;
+            }
+            updateContext.downloadFile(url, hash, target, new UpdateContext.DownloadFileListener() {
+                @Override
+                public void onDownloadCompleted(DownloadTaskParams params) {
+                    ApkInstaller.install(reactContext, params.targetFile, url, promise);
+                }
+
+                @Override
+                public void onDownloadFailed(Throwable error) {
+                    promise.reject(ErrorCodes.DOWNLOAD_FAILED, error);
+                }
+            });
+        } catch (Throwable error) {
+            promise.reject(ErrorCodes.APK_INSTALL_FAILED, error);
+        }
+    }
+
+    public void downloadPatchFromPackage(final ReadableMap options, final Promise promise) {
+        String url = readRequiredString(options, "updateUrl", promise);
+        if (url == null) {
+            return;
+        }
+        String hash = readRequiredString(options, "hash", promise);
+        if (hash == null) {
+            return;
+        }
+        updateContext.downloadPatchFromApk(url, hash, downloadListener(promise));
+    }
+
+    public void downloadPatchFromPpk(final ReadableMap options, final Promise promise) {
+        String url = readRequiredString(options, "updateUrl", promise);
+        if (url == null) {
+            return;
+        }
+        String hash = readRequiredString(options, "hash", promise);
+        if (hash == null) {
+            return;
+        }
+        String originHash = readRequiredString(options, "originHash", promise);
+        if (originHash == null) {
+            return;
+        }
+        updateContext.downloadPatchFromPpk(url, hash, originHash, downloadListener(promise));
+    }
+
+    public void reloadUpdate(final ReadableMap options, final Promise promise) {
+        String hash = readRequiredString(options, "hash", promise);
+        if (hash == null) {
+            return;
+        }
+        restartApp(hash, promise);
+    }
+
+    public void restartApp(@Nullable final String hash, final Promise promise) {
+        // Two hops (CODE_AUDIT 2.2): the switch (bundle digest + commit) and
+        // the launch resolution run on the state serial thread like every
+        // other state write; only the React reload itself is posted to the
+        // UI thread. A failure at either hop rejects with RESTART_FAILED.
+        StateSerialRunner.run(promise, ErrorCodes.RESTART_FAILED, "restartApp", new StateSerialRunner.Operation() {
+            @Override
+            public void run() throws Throwable {
+                final String bundlePath = ReactReloadManager.prepareRestart(updateContext, hash);
+                UiThreadRunner.run(promise, ErrorCodes.RESTART_FAILED, "restartApp", new UiThreadRunner.Operation() {
+                    @Override
+                    public void run() throws Throwable {
+                        ReactReloadManager.reload(updateContext, reactContext, bundlePath);
+                        promise.resolve(true);
+                    }
+                });
+            }
+        });
+    }
+
+    public void setNeedUpdate(final ReadableMap options, final Promise promise) {
+        final String hash = readRequiredString(options, "hash", promise);
+        if (hash == null) {
+            return;
+        }
+        StateSerialRunner.run(promise, ErrorCodes.SWITCH_VERSION_FAILED, "switchVersionLater", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                updateContext.switchVersion(hash);
+                promise.resolve(true);
+            }
+        });
+    }
+
+    public void markSuccess(final String expectedHash, final Promise promise) {
+        StateSerialRunner.run(promise, ErrorCodes.MARK_SUCCESS_FAILED, "markSuccess", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                promise.resolve(updateContext.markSuccess(expectedHash));
+            }
+        });
+    }
+
+    public void getBundleHash(final Promise promise) {
+        // Threading lives in UpdateContext (download executor); resolve is
+        // thread-safe. Never rejects — empty string means "unknown".
+        updateContext.getBundleHash(new UpdateContext.BundleHashListener() {
+            @Override
+            public void onBundleHash(String hash) {
+                promise.resolve(hash);
+            }
+        });
+    }
+
+    public void resetToPackagedBundle(final Promise promise) {
+        StateSerialRunner.run(promise, ErrorCodes.RESET_FAILED, "resetToPackagedBundle", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                updateContext.resetToPackagedBundle();
+                promise.resolve(true);
+            }
+        });
+    }
+
+    /**
+     * Raw response cached by the native cold-start check, for the JS side to
+     * reuse instead of re-checking (§10.3). Empty string when absent; never
+     * rejects.
+     */
+    public void getNativeCheckCache(final Promise promise) {
+        String cached = updateContext.getKv(NativeCheckOrchestrator.KEY_RESP_CACHE);
+        promise.resolve(cached == null ? "" : cached);
+    }
+
+    /**
+     * Provisioning for the native cold-start update check
+     * (NATIVE_CHECKUPDATE_DESIGN §10.1): the raw JSON persists as-is and is
+     * parsed on read by the orchestrator; absent config = check disabled.
+     * Validated at write time — a corrupt config would otherwise silently
+     * disable the native check forever with no signal.
+     */
+    public void markJsCheckCompleted(final String config, final Promise promise) {
+        if (requireNonEmpty(config, "config", promise) == null) {
+            return;
+        }
+        NativeCheckOrchestrator.markJsCheckCompleted(config);
+        promise.resolve(true);
+    }
+
+    public void syncNativeConfig(final String config, final Promise promise) {
+        if (requireNonEmpty(config, "config", promise) == null) {
+            return;
+        }
+        try {
+            new JSONObject(config);
+        } catch (JSONException e) {
+            promise.reject(ErrorCodes.INVALID_OPTIONS, "config must be a JSON object string", e);
+            return;
+        }
+        StateSerialRunner.run(promise, ErrorCodes.FILE_OPERATION_FAILED, "syncNativeConfig", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                updateContext.setKv(NativeCheckOrchestrator.KEY_CONFIG, config);
+                promise.resolve(true);
+            }
+        });
+    }
+
+    public void setUuid(final String uuid, final Promise promise) {
+        if (requireNonEmpty(uuid, "uuid", promise) == null) {
+            return;
+        }
+        StateSerialRunner.run(promise, ErrorCodes.FILE_OPERATION_FAILED, "setUuid", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                updateContext.setKv("uuid", uuid);
+                promise.resolve(true);
+            }
+        });
+    }
+
+    public void setLocalHashInfo(final String hash, final String info, final Promise promise) {
+        if (requireNonEmpty(hash, "hash", promise) == null) {
+            return;
+        }
+        if (!isValidHashInfo(info)) {
+            promise.reject(ErrorCodes.INVALID_HASH_INFO, "setLocalHashInfo failed: invalid json string");
+            return;
+        }
+        // A state write that did not reach disk (SharedPreferences commit
+        // false) is FILE_OPERATION_FAILED, distinct from malformed input.
+        StateSerialRunner.run(promise, ErrorCodes.FILE_OPERATION_FAILED, "setLocalHashInfo", new StateSerialRunner.Operation() {
+            @Override
+            public void run() {
+                updateContext.setKv("hash_" + hash, info);
+                promise.resolve(true);
+            }
+        });
+    }
+
+    public void getLocalHashInfo(final String hash, final Promise promise) {
+        if (requireNonEmpty(hash, "hash", promise) == null) {
+            return;
+        }
+        String value = updateContext.getKv("hash_" + hash);
+        if (value == null || value.isEmpty()) {
+            // No record (iOS resolves nil the same way): JS treats it as {}.
+            // Only a record that exists and is not a JSON object is invalid.
+            promise.resolve(null);
+            return;
+        }
+        if (!isValidHashInfo(value)) {
+            promise.reject(ErrorCodes.INVALID_HASH_INFO, "getLocalHashInfo failed: invalid json string");
+            return;
+        }
+
+        promise.resolve(value);
+    }
+}

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

@@ -0,0 +1,51 @@
+/**
+ * [INPUT]: 依赖 TurboReactPackage、ReactModuleInfo、BuildConfig 架构标志与 UpdateModule
+ * [OUTPUT]: 对外提供 UpdatePackage，按模块名构造 Pakta 原生模块并声明 Codegen/TurboModule 元数据
+ * [POS]: Android React Native 自动链接注册入口，只负责发现与实例化，不执行更新用例
+ */
+package cn.reactnative.modules.update;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import java.util.HashMap;
+import java.util.Map;
+
+// TurboReactPackage and the 7-argument ReactModuleInfo are deprecated in
+// current React Native but still shipped; their replacements
+// (BaseReactPackage, the 6-argument constructor) only exist from RN 0.74,
+// and this module's peer floor is RN 0.59.
+@SuppressWarnings("deprecation")
+public class UpdatePackage extends TurboReactPackage {
+    @Nullable
+    @Override
+    public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+        return name.equals(UpdateModuleImpl.NAME) ? new UpdateModule(reactContext) : null;
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return new ReactModuleInfoProvider() {
+            @Override
+            public Map<String, ReactModuleInfo> getReactModuleInfos() {
+                final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+                boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+                moduleInfos.put(
+                        UpdateModuleImpl.NAME,
+                        new ReactModuleInfo(
+                                UpdateModuleImpl.NAME,
+                                UpdateModuleImpl.NAME,
+                                false, // canOverrideExistingModule
+                                false, // needsEagerInit
+                                true, // hasConstants
+                                false, // isCxxModule
+                                isTurboModule // isTurboModule
+                        ));
+                return moduleInfos;
+            }
+        };
+    }
+}

package/android/src/main/java/expo/modules/pakta/ExpoPaktaModule.kt

@@ -0,0 +1,15 @@
+/**
+ * [INPUT]: 依赖 Expo Modules Kotlin Module 与 ModuleDefinition 注册 DSL
+ * [OUTPUT]: 对外提供 ExpoPaktaModule，并注册稳定模块名 ExpoPakta
+ * [POS]: Expo Android 模块发现入口；更新能力由共享 React Native 桥和 ExpoPaktaPackage 的宿主钩子提供
+ */
+package expo.modules.pakta
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoPaktaModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoPakta")
+  }
+}

package/android/src/main/java/expo/modules/pakta/ExpoPaktaPackage.java

@@ -0,0 +1,29 @@
+/**
+ * [INPUT]: 依赖 Expo Package/ReactNativeHostHandler、Android Context 与共享 UpdateContext bundle 选择能力
+ * [OUTPUT]: 对外提供 ExpoPaktaPackage，为 Expo 宿主注册返回当前热更 bundle 的 HostHandler
+ * [POS]: Expo Android 生命周期适配层，只桥接宿主 bundle 文件选择，不复制下载、状态或回滚规则
+ */
+package expo.modules.pakta;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import cn.reactnative.modules.update.UpdateContext;
+import expo.modules.core.interfaces.Package;
+import expo.modules.core.interfaces.ReactNativeHostHandler;
+
+public class ExpoPaktaPackage  implements Package {
+    @Override
+    public List<ReactNativeHostHandler> createReactNativeHostHandlers(Context context) {
+        List<ReactNativeHostHandler> handlers = new ArrayList<>();
+        handlers.add(new ReactNativeHostHandler() {
+            @Nullable
+            @Override
+            public String getJSBundleFile(boolean useDeveloperSupport) {
+                return UpdateContext.getBundleUrl(context);
+            }
+        });
+        return handlers;
+    }
+}