@expo/repack-app 0.0.5 → 0.1.0

package/build/android/apktool.d.ts

@@ -0,0 +1,21 @@
+import type { NormalizedOptions } from '../types';
+/**
+ * Decode the APK file using APKTool.
+ */
+export declare function decodeApkAsync(apkPath: string, options: NormalizedOptions): Promise<string>;
+/**
+ * Rebuild the decoded APK file using APKTool.
+ */
+export declare function rebuildApkAsync(decodedApkRoot: string, options: NormalizedOptions): Promise<string>;
+/**
+ * Add the bundle assets to the decoded APK.
+ */
+export declare function addBundleAssetsToDecodedApkAsync({ decodedApkRoot, assetRoot, bundleOutputPath, }: {
+    decodedApkRoot: string;
+    assetRoot: string;
+    bundleOutputPath: string;
+}): Promise<void>;
+/**
+ * Update the apktool.yml `renameManifestPackage`
+ */
+export declare function addRenameManifestPackageAsync(decodedApkRoot: string, packageName: string): Promise<void>;

package/build/android/apktool.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRenameManifestPackageAsync = exports.addBundleAssetsToDecodedApkAsync = exports.rebuildApkAsync = exports.decodeApkAsync = void 0;
+const steps_1 = require("@expo/steps");
+const promises_1 = __importDefault(require("fs/promises"));
+const glob_1 = require("glob");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const xml2js_1 = require("xml2js");
+let cachedApktoolPath = null;
+/**
+ * Decode the APK file using APKTool.
+ */
+async function decodeApkAsync(apkPath, options) {
+    const { workingDirectory } = options;
+    const apktoolPath = await getApktoolPathAsync();
+    const outputPath = 'decoded-apk';
+    await (0, steps_1.spawnAsync)('java', ['-jar', apktoolPath, 'decode', apkPath, '-s', '-o', outputPath], options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
+        : { cwd: workingDirectory });
+    return node_path_1.default.join(workingDirectory, outputPath);
+}
+exports.decodeApkAsync = decodeApkAsync;
+/**
+ * Rebuild the decoded APK file using APKTool.
+ */
+async function rebuildApkAsync(decodedApkRoot, options) {
+    const { workingDirectory } = options;
+    const apktoolPath = await getApktoolPathAsync();
+    const apktoolPackedApkName = 'apktool-packed.apk';
+    const apktoolPackedApkPath = node_path_1.default.resolve(workingDirectory, apktoolPackedApkName);
+    await (0, steps_1.spawnAsync)('java', ['-jar', apktoolPath, 'build', '-o', apktoolPackedApkPath, '--use-aapt2', decodedApkRoot], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    return apktoolPackedApkPath;
+}
+exports.rebuildApkAsync = rebuildApkAsync;
+/**
+ * Add the bundle assets to the decoded APK.
+ */
+async function addBundleAssetsToDecodedApkAsync({ decodedApkRoot, assetRoot, bundleOutputPath, }) {
+    await promises_1.default.copyFile(bundleOutputPath, node_path_1.default.join(decodedApkRoot, 'assets', 'index.android.bundle'));
+    const assetSet = await copyAssetsAsync(assetRoot, node_path_1.default.join(decodedApkRoot, 'res'));
+    await addApktoolResourceAsync(decodedApkRoot, assetSet);
+}
+exports.addBundleAssetsToDecodedApkAsync = addBundleAssetsToDecodedApkAsync;
+/**
+ * Update the apktool.yml `renameManifestPackage`
+ */
+async function addRenameManifestPackageAsync(decodedApkRoot, packageName) {
+    const apktoolYmlPath = node_path_1.default.join(decodedApkRoot, 'apktool.yml');
+    let apktoolYml = await promises_1.default.readFile(apktoolYmlPath, 'utf8');
+    apktoolYml = apktoolYml.replace(/^(\s+renameManifestPackage:\s+)(.+)$/gm, `$1${packageName}`);
+    await promises_1.default.writeFile(apktoolYmlPath, apktoolYml);
+}
+exports.addRenameManifestPackageAsync = addRenameManifestPackageAsync;
+//#region Internals
+async function getApktoolPathAsync() {
+    if (!cachedApktoolPath) {
+        const matches = await (0, glob_1.glob)('apktool_*.jar', {
+            cwd: node_path_1.default.join(__dirname, '../../assets'),
+            absolute: true,
+        });
+        cachedApktoolPath = matches[0];
+        (0, node_assert_1.default)(cachedApktoolPath, 'Unable to find the APKTool JAR file.');
+    }
+    return cachedApktoolPath;
+}
+async function addApktoolResourceAsync(decodedApkRoot, assetSet) {
+    const apktoolPublicXmlPath = node_path_1.default.join(decodedApkRoot, 'res/values/public.xml');
+    // [0] Retrieve the current max resource ID and the existing drawable names
+    const contents = await promises_1.default.readFile(apktoolPublicXmlPath, 'utf8');
+    const parser = new xml2js_1.Parser();
+    const existingNameSet = new Set();
+    const xmlJs = await parser.parseStringPromise(contents);
+    let maxDrawableResId = 0;
+    let maxRawResId = 0;
+    let maxResId = 0;
+    for (const item of xmlJs.resources.public) {
+        const intId = parseInt(item.$.id, 16);
+        if (item.$.type === 'drawable') {
+            maxDrawableResId = Math.max(maxDrawableResId, intId);
+            existingNameSet.add(item.$.name);
+        }
+        else if (item.$.type === 'raw') {
+            maxRawResId = Math.max(maxRawResId, intId);
+            existingNameSet.add(item.$.name);
+        }
+        maxResId = Math.max(maxResId, intId);
+    }
+    // [1] Add new resources
+    (0, node_assert_1.default)(maxDrawableResId !== 0, 'Drawable resources must be defined.');
+    if (maxRawResId === 0) {
+        // If there are no raw resources, start a new resource IDs section.
+        // A resource ID section has 0x10000 bounary.
+        maxRawResId = (maxResId & 0xffff0000) + 0x10000;
+    }
+    const drawableResIdBoundary = (maxDrawableResId & 0xffff0000) + 0x10000;
+    const rawResIdBoundary = (maxRawResId & 0xffff0000) + 0x10000;
+    const newAssetSet = new Set([...assetSet].filter(({ name }) => !existingNameSet.has(name)));
+    for (const asset of newAssetSet) {
+        if (asset.type === 'drawable') {
+            maxDrawableResId += 1;
+            (0, node_assert_1.default)(maxDrawableResId < drawableResIdBoundary, 'Drawable resource ID boundary exceeded.');
+            xmlJs.resources.public.push({
+                $: { type: 'drawable', name: asset.name, id: `0x${maxDrawableResId.toString(16)}` },
+            });
+        }
+        else if (asset.type === 'raw') {
+            maxRawResId += 1;
+            (0, node_assert_1.default)(maxRawResId < rawResIdBoundary, 'Raw resource ID boundary exceeded.');
+            xmlJs.resources.public.push({
+                $: { type: 'raw', name: asset.name, id: `0x${maxRawResId.toString(16)}` },
+            });
+        }
+    }
+    // [2] Write the updated public.xml file
+    const builder = new xml2js_1.Builder();
+    const xml = builder.buildObject(xmlJs);
+    await promises_1.default.writeFile(apktoolPublicXmlPath, xml);
+}
+/**
+ * Returns the asset type based on the name.
+ */
+function getAssetType(name) {
+    if (name.startsWith('drawable'))
+        return 'drawable';
+    if (name === 'raw')
+        return 'raw';
+    throw new Error(`Unsupported asset type for ${name}`);
+}
+/**
+ * Copies files and directories from src to dest while maintaining the nested structure (up to the specified level).
+ * @param src The source folder path.
+ * @param dest The destination folder path.
+ * @param level The current depth level (starts at 0).
+ * @param maxLevel The maximum depth level to process.
+ */
+async function copyAssetsAsync(src, dest, level = 0, maxLevel = 2, assetType = undefined, assetSet = new Set()) {
+    await promises_1.default.mkdir(dest, { recursive: true });
+    const entries = await promises_1.default.readdir(src, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = node_path_1.default.join(src, entry.name);
+        const destPath = node_path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            const _assetType = assetType ?? getAssetType(entry.name);
+            if (level < maxLevel - 1) {
+                await copyAssetsAsync(srcPath, destPath, level + 1, maxLevel, _assetType, assetSet);
+            }
+            else {
+                // When the maximum level is reached, copy the directory without further recursion
+                await promises_1.default.mkdir(destPath, { recursive: true });
+            }
+        }
+        else {
+            await promises_1.default.copyFile(srcPath, destPath);
+            const { name } = node_path_1.default.parse(entry.name);
+            (0, node_assert_1.default)(assetType, 'Asset type must be defined.');
+            assetSet.add({ name, type: assetType });
+        }
+    }));
+    return assetSet;
+}
+//#endregion Internals

package/build/android/build-tools.d.ts

@@ -2,31 +2,24 @@ import type { AndroidSigningOptions, NormalizedOptions } from '../types';
 export interface AndroidTools {
     aapt2Path: string;
     apksignerPath: string;
+    dexdumpPath: string;
     zipalignPath: string;
 }
 /**
  * Get the paths to the Android build-tools.
  */
 export declare function getAndroidBuildToolsAsync(options?: NormalizedOptions): Promise<AndroidTools>;
-/**
- * Create an APK with proto-based resources.
- */
-export declare function createProtoBasedResourcesAsync(options: NormalizedOptions): Promise<{
-    androidManiestFilePath: string;
-    resourcesPbFilePath: string;
-}>;
-/**
- * Create an APK with binary-based resources.
- */
-export declare function createBinaryBasedResourcesAsync(options: NormalizedOptions): Promise<string>;
 /**
  * Create a resigned & updated APK.
- * @param binaryApkPath The path to the binary-based resources APK returned from `createBinaryBasedResourcesAsync()`.
- * @param appConfigPath The path to the app.config file returned from `generateAppConfigAsync()`.
+ * @param unzippedApkRoot The root directory of the unzipped APK working directory.
  * @returns
  */
-export declare function createResignedApkAsync(binaryApkPath: string, appConfigPath: string, options: NormalizedOptions, signingOptions: AndroidSigningOptions): Promise<string>;
+export declare function createResignedApkAsync(unzippedApkRoot: string, options: NormalizedOptions, signingOptions: AndroidSigningOptions): Promise<string>;
 /**
  * Find the latest build-tools directory in the `ANDROID_SDK_ROOT` directory.
  */
 export declare function findLatestBuildToolsDirAsync(): Promise<string | null>;
+/**
+ * Search for classes in the APK with the given app ID pattern passing to grep.
+ */
+export declare function searchDexClassesAsync(unzipApkRoot: string, grepAppIdPattern: string): Promise<Set<string>>;

package/build/android/build-tools.js

@@ -3,9 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findLatestBuildToolsDirAsync = exports.createResignedApkAsync = exports.createBinaryBasedResourcesAsync = exports.createProtoBasedResourcesAsync = exports.getAndroidBuildToolsAsync = void 0;
+exports.searchDexClassesAsync = exports.findLatestBuildToolsDirAsync = exports.createResignedApkAsync = exports.getAndroidBuildToolsAsync = void 0;
 const steps_1 = require("@expo/steps");
-const glob_1 = require("glob");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -20,79 +19,29 @@ async function getAndroidBuildToolsAsync(options) {
         cachedAndroidTools = {
             aapt2Path: node_path_1.default.join(androidBuildToolsDir, 'aapt2'),
             apksignerPath: node_path_1.default.join(androidBuildToolsDir, 'apksigner'),
+            dexdumpPath: node_path_1.default.join(androidBuildToolsDir, 'dexdump'),
             zipalignPath: node_path_1.default.join(androidBuildToolsDir, 'zipalign'),
         };
     }
     return cachedAndroidTools;
 }
 exports.getAndroidBuildToolsAsync = getAndroidBuildToolsAsync;
-/**
- * Create an APK with proto-based resources.
- */
-async function createProtoBasedResourcesAsync(options) {
-    const { sourceAppPath, workingDirectory } = options;
-    const { aapt2Path } = await getAndroidBuildToolsAsync(options);
-    const protoApkPath = node_path_1.default.join(workingDirectory, 'proto.apk');
-    await (0, steps_1.spawnAsync)(aapt2Path, ['convert', '-o', protoApkPath, '--output-format', 'proto', '--keep-raw-values', sourceAppPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    await (0, steps_1.spawnAsync)('unzip', [protoApkPath, '-d', workingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    const removeFiles = await (0, glob_1.glob)('**/*', {
-        cwd: workingDirectory,
-        maxDepth: 1,
-        ignore: ['resources.pb', 'AndroidManifest.xml', 'res/**'],
-        absolute: true,
-    });
-    await Promise.all(removeFiles.map((file) => promises_1.default.rm(file, { recursive: true })));
-    return {
-        androidManiestFilePath: node_path_1.default.join(workingDirectory, 'AndroidManifest.xml'),
-        resourcesPbFilePath: node_path_1.default.join(workingDirectory, 'resources.pb'),
-    };
-}
-exports.createProtoBasedResourcesAsync = createProtoBasedResourcesAsync;
-/**
- * Create an APK with binary-based resources.
- */
-async function createBinaryBasedResourcesAsync(options) {
-    const { workingDirectory } = options;
-    const { aapt2Path } = await getAndroidBuildToolsAsync(options);
-    const protoUpdatedApkPath = node_path_1.default.join(workingDirectory, 'proto-updated.apk');
-    const binaryApkPath = node_path_1.default.join(workingDirectory, 'binary.apk');
-    await (0, steps_1.spawnAsync)('zip', ['-r', '-0', protoUpdatedApkPath, 'resources.pb', 'AndroidManifest.xml', 'res'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
-        : { cwd: workingDirectory });
-    await (0, steps_1.spawnAsync)(aapt2Path, [
-        'convert',
-        '-o',
-        binaryApkPath,
-        '--output-format',
-        'binary',
-        '--keep-raw-values',
-        protoUpdatedApkPath,
-    ], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    return binaryApkPath;
-}
-exports.createBinaryBasedResourcesAsync = createBinaryBasedResourcesAsync;
 /**
  * Create a resigned & updated APK.
- * @param binaryApkPath The path to the binary-based resources APK returned from `createBinaryBasedResourcesAsync()`.
- * @param appConfigPath The path to the app.config file returned from `generateAppConfigAsync()`.
+ * @param unzippedApkRoot The root directory of the unzipped APK working directory.
  * @returns
  */
-async function createResignedApkAsync(binaryApkPath, appConfigPath, options, signingOptions) {
+async function createResignedApkAsync(unzippedApkRoot, options, signingOptions) {
     const { workingDirectory } = options;
     const { apksignerPath, zipalignPath } = await getAndroidBuildToolsAsync(options);
-    const unzipWorkingDirectory = node_path_1.default.join(workingDirectory, 'unzip');
     const resignedApkPath = node_path_1.default.join(workingDirectory, 'resigned.apk');
-    const resignedApkUnalignedPath = node_path_1.default.join(workingDirectory, 'resigned-unaligned.apk');
-    await promises_1.default.mkdir(unzipWorkingDirectory, { recursive: true });
-    await (0, steps_1.spawnAsync)('unzip', [options.sourceAppPath, '-d', unzipWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    await (0, steps_1.spawnAsync)('unzip', ['-o', binaryApkPath, '-d', unzipWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    await promises_1.default.copyFile(appConfigPath, node_path_1.default.join(unzipWorkingDirectory, 'assets', 'app.config'));
+    const resignedApkUnalignedPath = node_path_1.default.resolve(workingDirectory, 'resigned-unaligned.apk');
     await (0, steps_1.spawnAsync)('zip', ['-r', '-0', resignedApkUnalignedPath, 'lib', 'resources.arsc'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: unzipWorkingDirectory }
-        : { cwd: unzipWorkingDirectory });
+        ? { logger: options.logger, stdio: 'pipe', cwd: unzippedApkRoot }
+        : { cwd: unzippedApkRoot });
     await (0, steps_1.spawnAsync)('zip', ['-r', resignedApkUnalignedPath, '.', '-x', 'lib/*', '-x', 'resources.arsc'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: unzipWorkingDirectory }
-        : { cwd: unzipWorkingDirectory });
+        ? { logger: options.logger, stdio: 'pipe', cwd: unzippedApkRoot }
+        : { cwd: unzippedApkRoot });
     await (0, steps_1.spawnAsync)(zipalignPath, ['-v', '-p', '4', resignedApkUnalignedPath, resignedApkPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
     const signerArgs = [
         'sign',
@@ -149,3 +98,20 @@ async function findLatestBuildToolsDirAsync() {
     }
 }
 exports.findLatestBuildToolsDirAsync = findLatestBuildToolsDirAsync;
+/**
+ * Search for classes in the APK with the given app ID pattern passing to grep.
+ */
+async function searchDexClassesAsync(unzipApkRoot, grepAppIdPattern) {
+    const { dexdumpPath } = await getAndroidBuildToolsAsync();
+    const grepPattern = `"^  Class descriptor  : 'L${grepAppIdPattern.replace(/\./g, '/')}\\/"`;
+    const { stdout } = await (0, steps_1.spawnAsync)(dexdumpPath, ['classes*.dex', '|', 'grep', grepPattern], {
+        cwd: unzipApkRoot,
+        shell: true,
+    });
+    const classes = stdout
+        .split('\n')
+        .map((line) => line.match(/Class descriptor\s+?:\s+?'L(.+);'/)?.[1].replace(/\//g, '.'))
+        .filter(Boolean);
+    return new Set(classes);
+}
+exports.searchDexClassesAsync = searchDexClassesAsync;

package/build/android/index.js

@@ -5,9 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repackAppAndroidAsync = void 0;
 const config_1 = require("@expo/config");
+const steps_1 = require("@expo/steps");
+const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const picocolors_1 = __importDefault(require("picocolors"));
+const apktool_1 = require("./apktool");
 const build_tools_1 = require("./build-tools");
 const resources_1 = require("./resources");
 const expo_1 = require("../expo");
@@ -23,27 +26,55 @@ async function repackAppAndroidAsync(_options) {
         isPublicConfig: true,
         skipSDKVersionRequirement: true,
     });
-    const updatesRuntimeVersion = await (0, expo_1.resolveRuntimeVersionAsync)(options, exp);
+    const decodedApkRoot = await (0, apktool_1.decodeApkAsync)(node_path_1.default.resolve(options.sourceAppPath), options);
+    (0, node_assert_1.default)(exp.android?.package, 'Expected app ID (`android.package`) to be defined in app.json');
+    const updatesRuntimeVersion = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot)
+        ? await (0, expo_1.resolveRuntimeVersionAsync)(options, exp)
+        : null;
     logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
-    logger.info(`Unzipping APK and creating proto based resources`);
-    const { androidManiestFilePath, resourcesPbFilePath } = await (0, build_tools_1.createProtoBasedResourcesAsync)(options);
-    logger.info(`Finished unzipping APK and creating proto based resources ✅`);
+    if (options.exportEmbedOptions != null) {
+        logger.info(`Generating bundle`);
+        const { assetRoot, bundleOutputPath } = await (0, expo_1.generateBundleAssetsAsync)(exp, options);
+        logger.info(`Finished generating bundle ✅`);
+        logger.info(`Adding bundled resources`);
+        await (0, apktool_1.addBundleAssetsToDecodedApkAsync)({
+            decodedApkRoot,
+            assetRoot,
+            bundleOutputPath,
+        });
+        logger.info(`Finished adding bundled resources ✅`);
+    }
     logger.info(`Updating Androidmanifest.xml`);
-    await (0, resources_1.updateAndroidManifestAsync)(exp, androidManiestFilePath, options, updatesRuntimeVersion);
+    const androidManiestFilePath = node_path_1.default.join(decodedApkRoot, 'AndroidManifest.xml');
+    const androidManiestXml = await (0, resources_1.parseXmlFileAsync)(androidManiestFilePath);
+    const originalAppId = await (0, resources_1.queryAppIdFromManifestAsync)(androidManiestXml);
+    const dexClasses = await (0, build_tools_1.searchDexClassesAsync)(decodedApkRoot, originalAppId);
+    await (0, resources_1.updateAndroidManifestAsync)({
+        config: exp,
+        androidManiestXml,
+        dexClasses,
+        originalAppId,
+        options,
+        updatesRuntimeVersion,
+    });
+    await (0, apktool_1.addRenameManifestPackageAsync)(decodedApkRoot, exp.android?.package);
+    await (0, resources_1.buildXmlFileAsync)(androidManiestXml, androidManiestFilePath);
     logger.info(`Finished updating Androidmanifest.xml ✅`);
-    logger.info(`Updating resources.pb`);
-    await (0, resources_1.updateResourcesAsync)(exp, resourcesPbFilePath);
-    logger.info(`Finished updating resources.pb ✅`);
-    logger.info(`Creating binary based resources`);
-    const binaryApkPath = await (0, build_tools_1.createBinaryBasedResourcesAsync)(options);
-    logger.info(`Finished creating binary based resources ✅`);
+    logger.info(`Updating resources`);
+    await (0, resources_1.updateResourcesAsync)({ config: exp, decodedApkRoot });
+    logger.info(`Finished updating resources ✅`);
     logger.info(`Generating app config`);
     const appConfigPath = await (0, expo_1.generateAppConfigAsync)(options, exp);
+    await promises_1.default.copyFile(appConfigPath, node_path_1.default.join(decodedApkRoot, 'assets', 'app.config'));
     logger.info(`Finished generating app config ✅`);
     logger.info(`Creating updated apk`);
-    const outputApk = await (0, build_tools_1.createResignedApkAsync)(binaryApkPath, appConfigPath, options, {
+    const apktoolPackedApkPath = await (0, apktool_1.rebuildApkAsync)(decodedApkRoot, options);
+    const unzippedApkRoot = node_path_1.default.join(workingDirectory, 'unzip');
+    await promises_1.default.mkdir(unzippedApkRoot, { recursive: true });
+    await (0, steps_1.spawnAsync)('unzip', ['-o', apktoolPackedApkPath, '-d', unzippedApkRoot], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    const outputApk = await (0, build_tools_1.createResignedApkAsync)(unzippedApkRoot, options, {
         keyStorePath: options.androidSigningOptions?.keyStorePath ??
-            node_path_1.default.resolve(__dirname, '../assets/debug.keystore'),
+            node_path_1.default.resolve(__dirname, '../../assets/debug.keystore'),
         keyStorePassword: options.androidSigningOptions?.keyStorePassword ?? 'android',
         keyAlias: options.androidSigningOptions?.keyAlias,
         keyPassword: options.androidSigningOptions?.keyPassword,
@@ -52,7 +83,7 @@ async function repackAppAndroidAsync(_options) {
     await promises_1.default.rename(outputApk, options.outputPath);
     if (!options.skipWorkingDirCleanup) {
         try {
-            await promises_1.default.rmdir(workingDirectory, { recursive: true });
+            await promises_1.default.rm(workingDirectory, { recursive: true });
         }
         catch { }
     }

package/build/android/resources.d.ts

@@ -1,10 +1,61 @@
 import { type ExpoConfig } from '@expo/config';
 import type { NormalizedOptions } from '../types';
+export interface XmlNode {
+    $?: {
+        [key: string]: string;
+    };
+    _?: string;
+    [key: string]: any;
+}
+export interface AndroidManifestType {
+    manifest: {
+        $: {
+            package: string;
+        };
+        application: {
+            $?: Record<string, string>;
+            'meta-data'?: XmlNode[];
+            activity?: {
+                $?: Record<string, string>;
+                'intent-filter'?: {
+                    action?: {
+                        $: Record<string, string>;
+                    }[];
+                    category?: {
+                        $: Record<string, string>;
+                    }[];
+                }[];
+            }[];
+        }[];
+    };
+}
 /**
- * Update resources inside the **resources.pb** file.
+ * Update resources in the decoded APK.
  */
-export declare function updateResourcesAsync(config: ExpoConfig, resourcesPbFilePath: string): Promise<void>;
+export declare function updateResourcesAsync({ config, decodedApkRoot, }: {
+    config: ExpoConfig;
+    decodedApkRoot: string;
+}): Promise<void>;
 /**
  * Update the proto-based AndroidManiest.xml.
  */
-export declare function updateAndroidManifestAsync(config: ExpoConfig, androidManiestFilePath: string, options: NormalizedOptions, updatesRuntimeVersion: string): Promise<void>;
+export declare function updateAndroidManifestAsync({ config, androidManiestXml, dexClasses, originalAppId, updatesRuntimeVersion, }: {
+    config: ExpoConfig;
+    androidManiestXml: AndroidManifestType;
+    dexClasses: Set<string>;
+    originalAppId: string;
+    options: NormalizedOptions;
+    updatesRuntimeVersion: string | null;
+}): Promise<void>;
+/**
+ * Parse the XML file.
+ */
+export declare function parseXmlFileAsync<T = XmlNode>(filePath: string): Promise<T>;
+/**
+ * Build the XML file from the given node.
+ */
+export declare function buildXmlFileAsync(rootNode: XmlNode, filePath: string): Promise<void>;
+/**
+ * Query the app ID from the AndroidManiest.xml.
+ */
+export declare function queryAppIdFromManifestAsync(androidManiestXml: XmlNode): Promise<string>;