@depup/expo__cli 55.0.16-depup.0

package/build/src/run/android/index.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "expoRunAndroid", {
+    enumerable: true,
+    get: function() {
+        return expoRunAndroid;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../log"));
+const _args = require("../../utils/args");
+const _errors = require("../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const expoRunAndroid = async (argv)=>{
+    const rawArgsMap = {
+        // Types
+        '--help': Boolean,
+        '--no-build-cache': Boolean,
+        '--no-install': Boolean,
+        '--no-bundler': Boolean,
+        '--variant': String,
+        '--binary': String,
+        '--app-id': String,
+        // Unstable, temporary fallback to disable active archs only behavior
+        // TODO: replace with better fallback option, like free-form passing gradle props
+        '--all-arch': Boolean,
+        '--port': Number,
+        // Aliases
+        '-p': '--port',
+        '-h': '--help'
+    };
+    const args = (0, _args.assertWithOptionsArgs)(rawArgsMap, {
+        argv,
+        permissive: true
+    });
+    // '-d' -> '--device': Boolean,
+    if (args['--help']) {
+        _log.exit((0, _chalk().default)`
+  {bold Description}
+    Run the native Android app locally
+
+  {bold Usage}
+    $ npx expo run:android <dir>
+
+  {bold Options} 
+    --no-build-cache       Clear the native build cache
+    --no-install           Skip installing dependencies
+    --no-bundler           Skip starting the bundler
+    --app-id <appId>       Custom Android application ID to launch.
+    --variant <name>       Build variant or product flavor and build variant. {dim Default: debug}
+    --binary <path>        Path to existing .apk or .aab to install.
+    -d, --device [device]  Device name to run the app on
+    -p, --port <port>      Port to start the dev server on. {dim Default: 8081}
+    -h, --help             Output usage information
+`, 0);
+    }
+    const { resolveStringOrBooleanArgsAsync } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../utils/resolveArgs.js")));
+    const parsed = await resolveStringOrBooleanArgsAsync(argv ?? [], rawArgsMap, {
+        '--device': Boolean,
+        '-d': '--device'
+    }).catch(_errors.logCmdError);
+    const { runAndroidAsync } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./runAndroidAsync.js")));
+    return runAndroidAsync(_path().default.resolve(parsed.projectRoot), {
+        // Parsed options
+        buildCache: !args['--no-build-cache'],
+        install: !args['--no-install'],
+        bundler: !args['--no-bundler'],
+        port: args['--port'],
+        variant: args['--variant'],
+        allArch: args['--all-arch'],
+        binary: args['--binary'],
+        appId: args['--app-id'],
+        // Custom parsed args
+        device: parsed.args['--device']
+    }).catch(_errors.logCmdError);
+};
+
+//# sourceMappingURL=index.js.map

package/build/src/run/android/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport arg from 'arg';\nimport chalk from 'chalk';\nimport path from 'path';\n\nimport { Command } from '../../../bin/cli';\nimport * as Log from '../../log';\nimport { assertWithOptionsArgs } from '../../utils/args';\nimport { logCmdError } from '../../utils/errors';\n\nexport const expoRunAndroid: Command = async (argv) => {\n  const rawArgsMap: arg.Spec = {\n    // Types\n    '--help': Boolean,\n    '--no-build-cache': Boolean,\n    '--no-install': Boolean,\n    '--no-bundler': Boolean,\n    '--variant': String,\n    '--binary': String,\n    '--app-id': String,\n    // Unstable, temporary fallback to disable active archs only behavior\n    // TODO: replace with better fallback option, like free-form passing gradle props\n    '--all-arch': Boolean,\n\n    '--port': Number,\n    // Aliases\n    '-p': '--port',\n\n    '-h': '--help',\n  };\n  const args = assertWithOptionsArgs(rawArgsMap, {\n    argv,\n\n    permissive: true,\n  });\n\n  // '-d' -> '--device': Boolean,\n\n  if (args['--help']) {\n    Log.exit(\n      chalk`\n  {bold Description}\n    Run the native Android app locally\n\n  {bold Usage}\n    $ npx expo run:android <dir>\n\n  {bold Options} \n    --no-build-cache       Clear the native build cache\n    --no-install           Skip installing dependencies\n    --no-bundler           Skip starting the bundler\n    --app-id <appId>       Custom Android application ID to launch.\n    --variant <name>       Build variant or product flavor and build variant. {dim Default: debug}\n    --binary <path>        Path to existing .apk or .aab to install.\n    -d, --device [device]  Device name to run the app on\n    -p, --port <port>      Port to start the dev server on. {dim Default: 8081}\n    -h, --help             Output usage information\n`,\n      0\n    );\n  }\n\n  const { resolveStringOrBooleanArgsAsync } = await import('../../utils/resolveArgs.js');\n  const parsed = await resolveStringOrBooleanArgsAsync(argv ?? [], rawArgsMap, {\n    '--device': Boolean,\n    '-d': '--device',\n  }).catch(logCmdError);\n\n  const { runAndroidAsync } = await import('./runAndroidAsync.js');\n\n  return runAndroidAsync(path.resolve(parsed.projectRoot), {\n    // Parsed options\n    buildCache: !args['--no-build-cache'],\n    install: !args['--no-install'],\n    bundler: !args['--no-bundler'],\n    port: args['--port'],\n    variant: args['--variant'],\n    allArch: args['--all-arch'],\n    binary: args['--binary'],\n    appId: args['--app-id'],\n    // Custom parsed args\n    device: parsed.args['--device'],\n  }).catch(logCmdError);\n};\n"],"names":["expoRunAndroid","argv","rawArgsMap","Boolean","String","Number","args","assertWithOptionsArgs","permissive","Log","exit","chalk","resolveStringOrBooleanArgsAsync","parsed","catch","logCmdError","runAndroidAsync","path","resolve","projectRoot","buildCache","install","bundler","port","variant","allArch","binary","appId","device"],"mappings":";;;;;+BAUaA;;;eAAAA;;;;gEARK;;;;;;;gEACD;;;;;;6DAGI;sBACiB;wBACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErB,MAAMA,iBAA0B,OAAOC;IAC5C,MAAMC,aAAuB;QAC3B,QAAQ;QACR,UAAUC;QACV,oBAAoBA;QACpB,gBAAgBA;QAChB,gBAAgBA;QAChB,aAAaC;QACb,YAAYA;QACZ,YAAYA;QACZ,qEAAqE;QACrE,iFAAiF;QACjF,cAAcD;QAEd,UAAUE;QACV,UAAU;QACV,MAAM;QAEN,MAAM;IACR;IACA,MAAMC,OAAOC,IAAAA,2BAAqB,EAACL,YAAY;QAC7CD;QAEAO,YAAY;IACd;IAEA,+BAA+B;IAE/B,IAAIF,IAAI,CAAC,SAAS,EAAE;QAClBG,KAAIC,IAAI,CACNC,IAAAA,gBAAK,CAAA,CAAC;;;;;;;;;;;;;;;;;AAiBZ,CAAC,EACK;IAEJ;IAEA,MAAM,EAAEC,+BAA+B,EAAE,GAAG,MAAM,mEAAA,QAAO;IACzD,MAAMC,SAAS,MAAMD,gCAAgCX,QAAQ,EAAE,EAAEC,YAAY;QAC3E,YAAYC;QACZ,MAAM;IACR,GAAGW,KAAK,CAACC,mBAAW;IAEpB,MAAM,EAAEC,eAAe,EAAE,GAAG,MAAM,mEAAA,QAAO;IAEzC,OAAOA,gBAAgBC,eAAI,CAACC,OAAO,CAACL,OAAOM,WAAW,GAAG;QACvD,iBAAiB;QACjBC,YAAY,CAACd,IAAI,CAAC,mBAAmB;QACrCe,SAAS,CAACf,IAAI,CAAC,eAAe;QAC9BgB,SAAS,CAAChB,IAAI,CAAC,eAAe;QAC9BiB,MAAMjB,IAAI,CAAC,SAAS;QACpBkB,SAASlB,IAAI,CAAC,YAAY;QAC1BmB,SAASnB,IAAI,CAAC,aAAa;QAC3BoB,QAAQpB,IAAI,CAAC,WAAW;QACxBqB,OAAOrB,IAAI,CAAC,WAAW;QACvB,qBAAqB;QACrBsB,QAAQf,OAAOP,IAAI,CAAC,WAAW;IACjC,GAAGQ,KAAK,CAACC,mBAAW;AACtB"}

package/build/src/run/android/resolveDevice.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveDeviceAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveDeviceAsync;
+    }
+});
+const _AndroidDeviceManager = require("../../start/platforms/android/AndroidDeviceManager");
+const _hints = require("../hints");
+const debug = require('debug')('expo:android:resolveDevice');
+async function resolveDeviceAsync(device) {
+    if (!device) {
+        const manager = await _AndroidDeviceManager.AndroidDeviceManager.resolveAsync();
+        debug(`Resolved default device (name: ${manager.device.name}, pid: ${manager.device.pid})`);
+        return manager;
+    }
+    debug(`Resolving device from argument: ${device}`);
+    const manager = device === true ? await _AndroidDeviceManager.AndroidDeviceManager.resolveAsync({
+        shouldPrompt: true
+    }) : await _AndroidDeviceManager.AndroidDeviceManager.resolveFromNameAsync(device);
+    (0, _hints.logDeviceArgument)(manager.device.name);
+    return manager;
+}
+
+//# sourceMappingURL=resolveDevice.js.map

package/build/src/run/android/resolveDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveDevice.ts"],"sourcesContent":["import { AndroidDeviceManager } from '../../start/platforms/android/AndroidDeviceManager';\nimport { logDeviceArgument } from '../hints';\n\nconst debug = require('debug')('expo:android:resolveDevice');\n\n/** Given a `device` argument from the CLI, parse and prompt our way to a usable device for building. */\nexport async function resolveDeviceAsync(device?: string | boolean) {\n  if (!device) {\n    const manager = await AndroidDeviceManager.resolveAsync();\n    debug(`Resolved default device (name: ${manager.device.name}, pid: ${manager.device.pid})`);\n    return manager;\n  }\n\n  debug(`Resolving device from argument: ${device}`);\n  const manager =\n    device === true\n      ? // `--device` (no props after)\n        await AndroidDeviceManager.resolveAsync({ shouldPrompt: true })\n      : // `--device <name>`\n        await AndroidDeviceManager.resolveFromNameAsync(device);\n  logDeviceArgument(manager.device.name);\n  return manager;\n}\n"],"names":["resolveDeviceAsync","debug","require","device","manager","AndroidDeviceManager","resolveAsync","name","pid","shouldPrompt","resolveFromNameAsync","logDeviceArgument"],"mappings":";;;;+BAMsBA;;;eAAAA;;;sCANe;uBACH;AAElC,MAAMC,QAAQC,QAAQ,SAAS;AAGxB,eAAeF,mBAAmBG,MAAyB;IAChE,IAAI,CAACA,QAAQ;QACX,MAAMC,UAAU,MAAMC,0CAAoB,CAACC,YAAY;QACvDL,MAAM,CAAC,+BAA+B,EAAEG,QAAQD,MAAM,CAACI,IAAI,CAAC,OAAO,EAAEH,QAAQD,MAAM,CAACK,GAAG,CAAC,CAAC,CAAC;QAC1F,OAAOJ;IACT;IAEAH,MAAM,CAAC,gCAAgC,EAAEE,QAAQ;IACjD,MAAMC,UACJD,WAAW,OAEP,MAAME,0CAAoB,CAACC,YAAY,CAAC;QAAEG,cAAc;IAAK,KAE7D,MAAMJ,0CAAoB,CAACK,oBAAoB,CAACP;IACtDQ,IAAAA,wBAAiB,EAACP,QAAQD,MAAM,CAACI,IAAI;IACrC,OAAOH;AACT"}

package/build/src/run/android/resolveGradlePropsAsync.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveGradlePropsAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveGradlePropsAsync;
+    }
+});
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _adb = require("../../start/platforms/android/adb");
+const _errors = require("../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Supported ABIs for Android. see https://developer.android.com/ndk/guides/abis
+const VALID_ARCHITECTURES = [
+    'armeabi-v7a',
+    'arm64-v8a',
+    'x86',
+    'x86_64'
+];
+function assertVariant(variant) {
+    if (variant && typeof variant !== 'string') {
+        throw new _errors.CommandError('BAD_ARGS', '--variant must be a string');
+    }
+    return variant ?? 'debug';
+}
+async function resolveGradlePropsAsync(projectRoot, options, device) {
+    const variant = assertVariant(options.variant);
+    // NOTE(EvanBacon): Why would this be different? Can we get the different name?
+    const appName = 'app';
+    const apkDirectory = _path().default.join(projectRoot, 'android', appName, 'build', 'outputs', 'apk');
+    // buildDeveloperTrust -> buildtype: trust, flavors: buildDeveloper
+    // developmentDebug -> buildType: debug, flavors: development
+    // productionRelease -> buildType: release, flavors: production
+    // previewDebugOptimized -> buildType: debugOptimized, flavors: preview
+    const parts = variant.split(/(?=[A-Z])/);
+    // Special case: merge 'Optimized' suffix with preceding part, e.g. into 'debugOptimized'
+    let buildType = parts.pop() ?? 'debug';
+    if (parts.length > 0 && buildType === 'Optimized') {
+        buildType = parts.pop().toLowerCase() + buildType;
+    } else {
+        buildType = buildType.toLowerCase();
+    }
+    let apkVariantDirectory;
+    if (parts.length > 0) {
+        const flavorPath = parts[0].toLowerCase() + parts.slice(1).join('');
+        apkVariantDirectory = _path().default.join(apkDirectory, flavorPath, buildType);
+    } else {
+        apkVariantDirectory = _path().default.join(apkDirectory, buildType);
+    }
+    return {
+        appName,
+        buildType,
+        flavors: parts.map((v)=>v.toLowerCase()),
+        apkVariantDirectory,
+        architectures: await getConnectedDeviceABIS(buildType, device, options.allArch)
+    };
+}
+async function getConnectedDeviceABIS(buildType, device, allArch) {
+    // Follow the same behavior as iOS, only enable this for debug builds
+    // Support both 'debug' and 'debugOptimized' build types
+    const isDebugBuild = buildType === 'debug' || buildType === 'debugOptimized';
+    if (allArch || !isDebugBuild) {
+        return '';
+    }
+    const abis = await (0, _adb.getDeviceABIsAsync)(device);
+    const validAbis = abis.filter((abi)=>VALID_ARCHITECTURES.includes(abi));
+    return validAbis.filter((abi, i, arr)=>arr.indexOf(abi) === i).join(',');
+}
+
+//# sourceMappingURL=resolveGradlePropsAsync.js.map

package/build/src/run/android/resolveGradlePropsAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveGradlePropsAsync.ts"],"sourcesContent":["import path from 'path';\n\nimport { Device, getDeviceABIsAsync } from '../../start/platforms/android/adb';\nimport { CommandError } from '../../utils/errors';\n\n// Supported ABIs for Android. see https://developer.android.com/ndk/guides/abis\nconst VALID_ARCHITECTURES = ['armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'];\n\nexport type GradleProps = {\n  /** Directory for the APK based on the `variant`. */\n  apkVariantDirectory: string;\n  /** Name of the app, used in the `apkVariantDirectory`. */\n  appName: string;\n  /** Last section of the provided `variant`, indicates the starting directory of the file name for the output APK. E.g. \"debug\" or \"release\" */\n  buildType: string;\n  /** Used to assemble the APK, also included in the output APK filename. */\n  flavors?: string[];\n  /** Architectures to build for. */\n  architectures?: string;\n};\n\nfunction assertVariant(variant?: string) {\n  if (variant && typeof variant !== 'string') {\n    throw new CommandError('BAD_ARGS', '--variant must be a string');\n  }\n  return variant ?? 'debug';\n}\n\nexport async function resolveGradlePropsAsync(\n  projectRoot: string,\n  options: { variant?: string; allArch?: boolean },\n  device: Device\n): Promise<GradleProps> {\n  const variant = assertVariant(options.variant);\n  // NOTE(EvanBacon): Why would this be different? Can we get the different name?\n  const appName = 'app';\n\n  const apkDirectory = path.join(projectRoot, 'android', appName, 'build', 'outputs', 'apk');\n\n  // buildDeveloperTrust -> buildtype: trust, flavors: buildDeveloper\n  // developmentDebug -> buildType: debug, flavors: development\n  // productionRelease -> buildType: release, flavors: production\n  // previewDebugOptimized -> buildType: debugOptimized, flavors: preview\n  const parts = variant.split(/(?=[A-Z])/);\n\n  // Special case: merge 'Optimized' suffix with preceding part, e.g. into 'debugOptimized'\n  let buildType = parts.pop() ?? 'debug';\n  if (parts.length > 0 && buildType === 'Optimized') {\n    buildType = parts.pop()!.toLowerCase() + buildType;\n  } else {\n    buildType = buildType.toLowerCase();\n  }\n\n  let apkVariantDirectory: string;\n  if (parts.length > 0) {\n    const flavorPath = parts[0].toLowerCase() + parts.slice(1).join('');\n    apkVariantDirectory = path.join(apkDirectory, flavorPath, buildType);\n  } else {\n    apkVariantDirectory = path.join(apkDirectory, buildType);\n  }\n\n  return {\n    appName,\n    buildType,\n    flavors: parts.map((v) => v.toLowerCase()),\n    apkVariantDirectory,\n    architectures: await getConnectedDeviceABIS(buildType, device, options.allArch),\n  };\n}\n\nasync function getConnectedDeviceABIS(\n  buildType: string,\n  device: Device,\n  allArch?: boolean\n): Promise<string> {\n  // Follow the same behavior as iOS, only enable this for debug builds\n  // Support both 'debug' and 'debugOptimized' build types\n  const isDebugBuild = buildType === 'debug' || buildType === 'debugOptimized';\n  if (allArch || !isDebugBuild) {\n    return '';\n  }\n\n  const abis = await getDeviceABIsAsync(device);\n\n  const validAbis = abis.filter((abi) => VALID_ARCHITECTURES.includes(abi));\n  return validAbis.filter((abi, i, arr) => arr.indexOf(abi) === i).join(',');\n}\n"],"names":["resolveGradlePropsAsync","VALID_ARCHITECTURES","assertVariant","variant","CommandError","projectRoot","options","device","appName","apkDirectory","path","join","parts","split","buildType","pop","length","toLowerCase","apkVariantDirectory","flavorPath","slice","flavors","map","v","architectures","getConnectedDeviceABIS","allArch","isDebugBuild","abis","getDeviceABIsAsync","validAbis","filter","abi","includes","i","arr","indexOf"],"mappings":";;;;+BA4BsBA;;;eAAAA;;;;gEA5BL;;;;;;qBAE0B;wBACd;;;;;;AAE7B,gFAAgF;AAChF,MAAMC,sBAAsB;IAAC;IAAe;IAAa;IAAO;CAAS;AAezE,SAASC,cAAcC,OAAgB;IACrC,IAAIA,WAAW,OAAOA,YAAY,UAAU;QAC1C,MAAM,IAAIC,oBAAY,CAAC,YAAY;IACrC;IACA,OAAOD,WAAW;AACpB;AAEO,eAAeH,wBACpBK,WAAmB,EACnBC,OAAgD,EAChDC,MAAc;IAEd,MAAMJ,UAAUD,cAAcI,QAAQH,OAAO;IAC7C,+EAA+E;IAC/E,MAAMK,UAAU;IAEhB,MAAMC,eAAeC,eAAI,CAACC,IAAI,CAACN,aAAa,WAAWG,SAAS,SAAS,WAAW;IAEpF,mEAAmE;IACnE,6DAA6D;IAC7D,+DAA+D;IAC/D,uEAAuE;IACvE,MAAMI,QAAQT,QAAQU,KAAK,CAAC;IAE5B,yFAAyF;IACzF,IAAIC,YAAYF,MAAMG,GAAG,MAAM;IAC/B,IAAIH,MAAMI,MAAM,GAAG,KAAKF,cAAc,aAAa;QACjDA,YAAYF,MAAMG,GAAG,GAAIE,WAAW,KAAKH;IAC3C,OAAO;QACLA,YAAYA,UAAUG,WAAW;IACnC;IAEA,IAAIC;IACJ,IAAIN,MAAMI,MAAM,GAAG,GAAG;QACpB,MAAMG,aAAaP,KAAK,CAAC,EAAE,CAACK,WAAW,KAAKL,MAAMQ,KAAK,CAAC,GAAGT,IAAI,CAAC;QAChEO,sBAAsBR,eAAI,CAACC,IAAI,CAACF,cAAcU,YAAYL;IAC5D,OAAO;QACLI,sBAAsBR,eAAI,CAACC,IAAI,CAACF,cAAcK;IAChD;IAEA,OAAO;QACLN;QACAM;QACAO,SAAST,MAAMU,GAAG,CAAC,CAACC,IAAMA,EAAEN,WAAW;QACvCC;QACAM,eAAe,MAAMC,uBAAuBX,WAAWP,QAAQD,QAAQoB,OAAO;IAChF;AACF;AAEA,eAAeD,uBACbX,SAAiB,EACjBP,MAAc,EACdmB,OAAiB;IAEjB,qEAAqE;IACrE,wDAAwD;IACxD,MAAMC,eAAeb,cAAc,WAAWA,cAAc;IAC5D,IAAIY,WAAW,CAACC,cAAc;QAC5B,OAAO;IACT;IAEA,MAAMC,OAAO,MAAMC,IAAAA,uBAAkB,EAACtB;IAEtC,MAAMuB,YAAYF,KAAKG,MAAM,CAAC,CAACC,MAAQ/B,oBAAoBgC,QAAQ,CAACD;IACpE,OAAOF,UAAUC,MAAM,CAAC,CAACC,KAAKE,GAAGC,MAAQA,IAAIC,OAAO,CAACJ,SAASE,GAAGvB,IAAI,CAAC;AACxE"}

package/build/src/run/android/resolveInstallApkName.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveInstallApkNameAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveInstallApkNameAsync;
+    }
+});
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _adb = require("../../start/platforms/android/adb");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:run:android:resolveInstallApkName');
+async function resolveInstallApkNameAsync(device, { appName, buildType, flavors, apkVariantDirectory }) {
+    const availableCPUs = await (0, _adb.getDeviceABIsAsync)(device);
+    availableCPUs.push(_adb.DeviceABI.universal);
+    debug('Supported ABIs: ' + availableCPUs.join(', '));
+    debug('Searching for APK: ' + apkVariantDirectory);
+    // Check for cpu specific builds first
+    for (const availableCPU of availableCPUs){
+        const apkName = getApkFileName(appName, buildType, flavors, availableCPU);
+        const apkPath = _path().default.join(apkVariantDirectory, apkName);
+        debug('Checking for APK at:', apkPath);
+        if (_fs().default.existsSync(apkPath)) {
+            return apkName;
+        }
+    }
+    // Otherwise use the default apk named after the variant: app-debug.apk
+    const apkName = getApkFileName(appName, buildType, flavors);
+    const apkPath = _path().default.join(apkVariantDirectory, apkName);
+    debug('Checking for fallback APK at:', apkPath);
+    if (_fs().default.existsSync(apkPath)) {
+        return apkName;
+    }
+    return null;
+}
+function getApkFileName(appName, buildType, flavors, cpuArch) {
+    let apkName = `${appName}-`;
+    if (flavors) {
+        apkName += flavors.reduce((rest, flavor)=>`${rest}${flavor}-`, '');
+    }
+    if (cpuArch) {
+        apkName += `${cpuArch}-`;
+    }
+    apkName += `${buildType}.apk`;
+    return apkName;
+}
+
+//# sourceMappingURL=resolveInstallApkName.js.map

package/build/src/run/android/resolveInstallApkName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveInstallApkName.ts"],"sourcesContent":["import fs from 'fs';\nimport path from 'path';\n\nimport { GradleProps } from './resolveGradlePropsAsync';\nimport { Device, DeviceABI, getDeviceABIsAsync } from '../../start/platforms/android/adb';\n\nconst debug = require('debug')('expo:run:android:resolveInstallApkName') as typeof console.log;\n\nexport async function resolveInstallApkNameAsync(\n  device: Pick<Device, 'name' | 'pid'>,\n  { appName, buildType, flavors, apkVariantDirectory }: GradleProps\n) {\n  const availableCPUs = await getDeviceABIsAsync(device);\n  availableCPUs.push(DeviceABI.universal);\n\n  debug('Supported ABIs: ' + availableCPUs.join(', '));\n  debug('Searching for APK: ' + apkVariantDirectory);\n\n  // Check for cpu specific builds first\n  for (const availableCPU of availableCPUs) {\n    const apkName = getApkFileName(appName, buildType, flavors, availableCPU);\n    const apkPath = path.join(apkVariantDirectory, apkName);\n    debug('Checking for APK at:', apkPath);\n    if (fs.existsSync(apkPath)) {\n      return apkName;\n    }\n  }\n\n  // Otherwise use the default apk named after the variant: app-debug.apk\n  const apkName = getApkFileName(appName, buildType, flavors);\n  const apkPath = path.join(apkVariantDirectory, apkName);\n  debug('Checking for fallback APK at:', apkPath);\n  if (fs.existsSync(apkPath)) {\n    return apkName;\n  }\n\n  return null;\n}\n\nfunction getApkFileName(\n  appName: string,\n  buildType: string,\n  flavors?: string[] | null,\n  cpuArch?: string | null\n) {\n  let apkName = `${appName}-`;\n  if (flavors) {\n    apkName += flavors.reduce((rest, flavor) => `${rest}${flavor}-`, '');\n  }\n  if (cpuArch) {\n    apkName += `${cpuArch}-`;\n  }\n  apkName += `${buildType}.apk`;\n\n  return apkName;\n}\n"],"names":["resolveInstallApkNameAsync","debug","require","device","appName","buildType","flavors","apkVariantDirectory","availableCPUs","getDeviceABIsAsync","push","DeviceABI","universal","join","availableCPU","apkName","getApkFileName","apkPath","path","fs","existsSync","cpuArch","reduce","rest","flavor"],"mappings":";;;;+BAQsBA;;;eAAAA;;;;gEARP;;;;;;;gEACE;;;;;;qBAGqC;;;;;;AAEtD,MAAMC,QAAQC,QAAQ,SAAS;AAExB,eAAeF,2BACpBG,MAAoC,EACpC,EAAEC,OAAO,EAAEC,SAAS,EAAEC,OAAO,EAAEC,mBAAmB,EAAe;IAEjE,MAAMC,gBAAgB,MAAMC,IAAAA,uBAAkB,EAACN;IAC/CK,cAAcE,IAAI,CAACC,cAAS,CAACC,SAAS;IAEtCX,MAAM,qBAAqBO,cAAcK,IAAI,CAAC;IAC9CZ,MAAM,wBAAwBM;IAE9B,sCAAsC;IACtC,KAAK,MAAMO,gBAAgBN,cAAe;QACxC,MAAMO,UAAUC,eAAeZ,SAASC,WAAWC,SAASQ;QAC5D,MAAMG,UAAUC,eAAI,CAACL,IAAI,CAACN,qBAAqBQ;QAC/Cd,MAAM,wBAAwBgB;QAC9B,IAAIE,aAAE,CAACC,UAAU,CAACH,UAAU;YAC1B,OAAOF;QACT;IACF;IAEA,uEAAuE;IACvE,MAAMA,UAAUC,eAAeZ,SAASC,WAAWC;IACnD,MAAMW,UAAUC,eAAI,CAACL,IAAI,CAACN,qBAAqBQ;IAC/Cd,MAAM,iCAAiCgB;IACvC,IAAIE,aAAE,CAACC,UAAU,CAACH,UAAU;QAC1B,OAAOF;IACT;IAEA,OAAO;AACT;AAEA,SAASC,eACPZ,OAAe,EACfC,SAAiB,EACjBC,OAAyB,EACzBe,OAAuB;IAEvB,IAAIN,UAAU,GAAGX,QAAQ,CAAC,CAAC;IAC3B,IAAIE,SAAS;QACXS,WAAWT,QAAQgB,MAAM,CAAC,CAACC,MAAMC,SAAW,GAAGD,OAAOC,OAAO,CAAC,CAAC,EAAE;IACnE;IACA,IAAIH,SAAS;QACXN,WAAW,GAAGM,QAAQ,CAAC,CAAC;IAC1B;IACAN,WAAW,GAAGV,UAAU,IAAI,CAAC;IAE7B,OAAOU;AACT"}

package/build/src/run/android/resolveLaunchProps.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveLaunchPropsAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveLaunchPropsAsync;
+    }
+});
+function _configplugins() {
+    const data = require("@expo/config-plugins");
+    _configplugins = function() {
+        return data;
+    };
+    return data;
+}
+const _AndroidAppIdResolver = require("../../start/platforms/android/AndroidAppIdResolver");
+const _errors = require("../../utils/errors");
+async function getMainActivityAsync(projectRoot) {
+    const filePath = await _configplugins().AndroidConfig.Paths.getAndroidManifestAsync(projectRoot);
+    const androidManifest = await _configplugins().AndroidConfig.Manifest.readAndroidManifestAsync(filePath);
+    // Assert MainActivity defined.
+    const activity = await _configplugins().AndroidConfig.Manifest.getRunnableActivity(androidManifest);
+    if (!activity) {
+        throw new _errors.CommandError('ANDROID_MALFORMED', `${filePath} is missing a runnable activity element.`);
+    }
+    // Often this is ".MainActivity"
+    return activity.$['android:name'];
+}
+async function resolveLaunchPropsAsync(projectRoot, options) {
+    const mainActivity = await getMainActivityAsync(projectRoot);
+    const packageName = await new _AndroidAppIdResolver.AndroidAppIdResolver(projectRoot).getAppIdFromNativeAsync();
+    const customAppId = options.appId;
+    const launchActivity = customAppId && customAppId !== packageName ? `${customAppId}/${packageName}${mainActivity}` : `${packageName}/${mainActivity}`;
+    return {
+        mainActivity,
+        launchActivity,
+        packageName,
+        customAppId
+    };
+}
+
+//# sourceMappingURL=resolveLaunchProps.js.map

package/build/src/run/android/resolveLaunchProps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveLaunchProps.ts"],"sourcesContent":["import { AndroidConfig } from '@expo/config-plugins';\n\nimport { AndroidAppIdResolver } from '../../start/platforms/android/AndroidAppIdResolver';\nimport { CommandError } from '../../utils/errors';\n\nexport interface LaunchProps {\n  /**\n   * The \"common\" Android package name, configured through the app manifest.\n   * @see https://source.android.com/docs/core/architecture/hidl/code-style#package-names\n   */\n  packageName: string;\n  /**\n   * Optional customized application ID, used in product flavors.\n   * @see https://developer.android.com/build/build-variants#change-app-id\n   */\n  customAppId?: string;\n  /**\n   * The main activity to launch, by default this is `.MainActivity`.\n   * @see https://github.com/expo/expo/blob/c0aec226a43c0f186258a063a6145c3e52246f8a/templates/expo-template-bare-minimum/android/app/src/main/AndroidManifest.xml#L22\n   */\n  mainActivity: string;\n  /**\n   * The full launch activity reference used in the app intent to launch the app with `adb am start -n <launchActivity>`.\n   * Usually, this is structured as `<package-name>/.<activity-name>`.\n   * For product flavors, this is structured as `<custom-app-id>/<package-name>.<activity-name>`.\n   * @see https://developer.android.com/studio/command-line/adb#IntentSpec\n   */\n  launchActivity: string;\n}\n\nasync function getMainActivityAsync(projectRoot: string): Promise<string> {\n  const filePath = await AndroidConfig.Paths.getAndroidManifestAsync(projectRoot);\n  const androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(filePath);\n\n  // Assert MainActivity defined.\n  const activity = await AndroidConfig.Manifest.getRunnableActivity(androidManifest);\n  if (!activity) {\n    throw new CommandError(\n      'ANDROID_MALFORMED',\n      `${filePath} is missing a runnable activity element.`\n    );\n  }\n  // Often this is \".MainActivity\"\n  return activity.$['android:name'];\n}\n\nexport async function resolveLaunchPropsAsync(\n  projectRoot: string,\n  options: { appId?: string }\n): Promise<LaunchProps> {\n  const mainActivity = await getMainActivityAsync(projectRoot);\n  const packageName = await new AndroidAppIdResolver(projectRoot).getAppIdFromNativeAsync();\n  const customAppId = options.appId;\n\n  const launchActivity =\n    customAppId && customAppId !== packageName\n      ? `${customAppId}/${packageName}${mainActivity}`\n      : `${packageName}/${mainActivity}`;\n\n  return {\n    mainActivity,\n    launchActivity,\n    packageName,\n    customAppId,\n  };\n}\n"],"names":["resolveLaunchPropsAsync","getMainActivityAsync","projectRoot","filePath","AndroidConfig","Paths","getAndroidManifestAsync","androidManifest","Manifest","readAndroidManifestAsync","activity","getRunnableActivity","CommandError","$","options","mainActivity","packageName","AndroidAppIdResolver","getAppIdFromNativeAsync","customAppId","appId","launchActivity"],"mappings":";;;;+BA8CsBA;;;eAAAA;;;;yBA9CQ;;;;;;sCAEO;wBACR;AA2B7B,eAAeC,qBAAqBC,WAAmB;IACrD,MAAMC,WAAW,MAAMC,8BAAa,CAACC,KAAK,CAACC,uBAAuB,CAACJ;IACnE,MAAMK,kBAAkB,MAAMH,8BAAa,CAACI,QAAQ,CAACC,wBAAwB,CAACN;IAE9E,+BAA+B;IAC/B,MAAMO,WAAW,MAAMN,8BAAa,CAACI,QAAQ,CAACG,mBAAmB,CAACJ;IAClE,IAAI,CAACG,UAAU;QACb,MAAM,IAAIE,oBAAY,CACpB,qBACA,GAAGT,SAAS,wCAAwC,CAAC;IAEzD;IACA,gCAAgC;IAChC,OAAOO,SAASG,CAAC,CAAC,eAAe;AACnC;AAEO,eAAeb,wBACpBE,WAAmB,EACnBY,OAA2B;IAE3B,MAAMC,eAAe,MAAMd,qBAAqBC;IAChD,MAAMc,cAAc,MAAM,IAAIC,0CAAoB,CAACf,aAAagB,uBAAuB;IACvF,MAAMC,cAAcL,QAAQM,KAAK;IAEjC,MAAMC,iBACJF,eAAeA,gBAAgBH,cAC3B,GAAGG,YAAY,CAAC,EAAEH,cAAcD,cAAc,GAC9C,GAAGC,YAAY,CAAC,EAAED,cAAc;IAEtC,OAAO;QACLA;QACAM;QACAL;QACAG;IACF;AACF"}

package/build/src/run/android/resolveOptions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveOptionsAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveOptionsAsync;
+    }
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+const _resolveDevice = require("./resolveDevice");
+const _resolveGradlePropsAsync = require("./resolveGradlePropsAsync");
+const _resolveLaunchProps = require("./resolveLaunchProps");
+const _buildcacheproviders = require("../../utils/build-cache-providers");
+const _resolveBundlerProps = require("../resolveBundlerProps");
+async function resolveOptionsAsync(projectRoot, options) {
+    var _projectConfig_exp, _projectConfig_exp_experiments;
+    // Resolve the device before the gradle props because we need the device to be running to get the ABI.
+    const device = await (0, _resolveDevice.resolveDeviceAsync)(options.device);
+    const projectConfig = (0, _config().getConfig)(projectRoot);
+    const buildCacheProvider = await (0, _buildcacheproviders.resolveBuildCacheProvider)(((_projectConfig_exp = projectConfig.exp) == null ? void 0 : _projectConfig_exp.buildCacheProvider) ?? ((_projectConfig_exp_experiments = projectConfig.exp.experiments) == null ? void 0 : _projectConfig_exp_experiments.buildCacheProvider), projectRoot);
+    return {
+        ...await (0, _resolveBundlerProps.resolveBundlerPropsAsync)(projectRoot, options),
+        ...await (0, _resolveGradlePropsAsync.resolveGradlePropsAsync)(projectRoot, options, device.device),
+        ...await (0, _resolveLaunchProps.resolveLaunchPropsAsync)(projectRoot, options),
+        variant: options.variant ?? 'debug',
+        // Resolve the device based on the provided device id or prompt
+        // from a list of devices (connected or simulated) that are filtered by the scheme.
+        device,
+        buildCache: !!options.buildCache,
+        install: !!options.install,
+        buildCacheProvider
+    };
+}
+
+//# sourceMappingURL=resolveOptions.js.map

package/build/src/run/android/resolveOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveOptions.ts"],"sourcesContent":["import { BuildCacheProvider, getConfig } from '@expo/config';\n\nimport { resolveDeviceAsync } from './resolveDevice';\nimport { GradleProps, resolveGradlePropsAsync } from './resolveGradlePropsAsync';\nimport { LaunchProps, resolveLaunchPropsAsync } from './resolveLaunchProps';\nimport { AndroidDeviceManager } from '../../start/platforms/android/AndroidDeviceManager';\nimport { resolveBuildCacheProvider } from '../../utils/build-cache-providers';\nimport { BundlerProps, resolveBundlerPropsAsync } from '../resolveBundlerProps';\n\nexport type Options = {\n  variant?: string;\n  device?: boolean | string;\n  port?: number;\n  bundler?: boolean;\n  install?: boolean;\n  buildCache?: boolean;\n  allArch?: boolean;\n  binary?: string;\n  appId?: string;\n};\n\nexport type ResolvedOptions = GradleProps &\n  BundlerProps &\n  LaunchProps & {\n    variant: string;\n    buildCache: boolean;\n    device: AndroidDeviceManager;\n    install: boolean;\n    architectures?: string;\n    appId?: string;\n    buildCacheProvider?: BuildCacheProvider;\n  };\n\nexport async function resolveOptionsAsync(\n  projectRoot: string,\n  options: Options\n): Promise<ResolvedOptions> {\n  // Resolve the device before the gradle props because we need the device to be running to get the ABI.\n  const device = await resolveDeviceAsync(options.device);\n\n  const projectConfig = getConfig(projectRoot);\n  const buildCacheProvider = await resolveBuildCacheProvider(\n    projectConfig.exp?.buildCacheProvider ?? projectConfig.exp.experiments?.buildCacheProvider,\n    projectRoot\n  );\n\n  return {\n    ...(await resolveBundlerPropsAsync(projectRoot, options)),\n    ...(await resolveGradlePropsAsync(projectRoot, options, device.device)),\n    ...(await resolveLaunchPropsAsync(projectRoot, options)),\n    variant: options.variant ?? 'debug',\n    // Resolve the device based on the provided device id or prompt\n    // from a list of devices (connected or simulated) that are filtered by the scheme.\n    device,\n    buildCache: !!options.buildCache,\n    install: !!options.install,\n    buildCacheProvider,\n  };\n}\n"],"names":["resolveOptionsAsync","projectRoot","options","projectConfig","device","resolveDeviceAsync","getConfig","buildCacheProvider","resolveBuildCacheProvider","exp","experiments","resolveBundlerPropsAsync","resolveGradlePropsAsync","resolveLaunchPropsAsync","variant","buildCache","install"],"mappings":";;;;+BAiCsBA;;;eAAAA;;;;yBAjCwB;;;;;;+BAEX;yCACkB;oCACA;qCAEX;qCACa;AA0BhD,eAAeA,oBACpBC,WAAmB,EACnBC,OAAgB;QAOdC,oBAAyCA;IAL3C,sGAAsG;IACtG,MAAMC,SAAS,MAAMC,IAAAA,iCAAkB,EAACH,QAAQE,MAAM;IAEtD,MAAMD,gBAAgBG,IAAAA,mBAAS,EAACL;IAChC,MAAMM,qBAAqB,MAAMC,IAAAA,8CAAyB,EACxDL,EAAAA,qBAAAA,cAAcM,GAAG,qBAAjBN,mBAAmBI,kBAAkB,OAAIJ,iCAAAA,cAAcM,GAAG,CAACC,WAAW,qBAA7BP,+BAA+BI,kBAAkB,GAC1FN;IAGF,OAAO;QACL,GAAI,MAAMU,IAAAA,6CAAwB,EAACV,aAAaC,QAAQ;QACxD,GAAI,MAAMU,IAAAA,gDAAuB,EAACX,aAAaC,SAASE,OAAOA,MAAM,CAAC;QACtE,GAAI,MAAMS,IAAAA,2CAAuB,EAACZ,aAAaC,QAAQ;QACvDY,SAASZ,QAAQY,OAAO,IAAI;QAC5B,+DAA+D;QAC/D,mFAAmF;QACnFV;QACAW,YAAY,CAAC,CAACb,QAAQa,UAAU;QAChCC,SAAS,CAAC,CAACd,QAAQc,OAAO;QAC1BT;IACF;AACF"}

package/build/src/run/android/runAndroidAsync.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runAndroidAsync", {
+    enumerable: true,
+    get: function() {
+        return runAndroidAsync;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _resolveInstallApkName = require("./resolveInstallApkName");
+const _resolveOptions = require("./resolveOptions");
+const _exportEager = require("../../export/embed/exportEager");
+const _log = require("../../log");
+const _gradle = require("../../start/platforms/android/gradle");
+const _buildcacheproviders = require("../../utils/build-cache-providers");
+const _errors = require("../../utils/errors");
+const _nodeEnv = require("../../utils/nodeEnv");
+const _port = require("../../utils/port");
+const _scheme = require("../../utils/scheme");
+const _ensureNativeProject = require("../ensureNativeProject");
+const _hints = require("../hints");
+const _startBundler = require("../startBundler");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:run:android');
+async function runAndroidAsync(projectRoot, { install, ...options }) {
+    var _options_variant, _this;
+    // NOTE: This is a guess, the developer can overwrite with `NODE_ENV`.
+    const isProduction = (_options_variant = options.variant) == null ? void 0 : _options_variant.toLowerCase().endsWith('release');
+    (0, _nodeEnv.setNodeEnv)(isProduction ? 'production' : 'development');
+    (0, _nodeEnv.loadEnvFiles)(projectRoot);
+    await (0, _ensureNativeProject.ensureNativeProjectAsync)(projectRoot, {
+        platform: 'android',
+        install
+    });
+    const props = await (0, _resolveOptions.resolveOptionsAsync)(projectRoot, options);
+    if (!options.binary && props.buildCacheProvider) {
+        const localPath = await (0, _buildcacheproviders.resolveBuildCache)({
+            projectRoot,
+            platform: 'android',
+            provider: props.buildCacheProvider,
+            runOptions: options
+        });
+        if (localPath) {
+            options.binary = localPath;
+        }
+    }
+    debug('Package name: ' + props.packageName);
+    _log.Log.log('› Building app...');
+    const androidProjectRoot = _path().default.join(projectRoot, 'android');
+    let shouldUpdateBuildCache = false;
+    if (!options.binary) {
+        let eagerBundleOptions;
+        if (isProduction) {
+            eagerBundleOptions = JSON.stringify(await (0, _exportEager.exportEagerAsync)(projectRoot, {
+                dev: false,
+                platform: 'android'
+            }));
+        }
+        await (0, _gradle.assembleAsync)(androidProjectRoot, {
+            variant: props.variant,
+            port: props.port,
+            appName: props.appName,
+            buildCache: props.buildCache,
+            architectures: props.architectures,
+            eagerBundleOptions
+        });
+        shouldUpdateBuildCache = true;
+        // Ensure the port hasn't become busy during the build.
+        if (props.shouldStartBundler && !await (0, _port.ensurePortAvailabilityAsync)(projectRoot, props)) {
+            props.shouldStartBundler = false;
+        }
+    }
+    const manager = await (0, _startBundler.startBundlerAsync)(projectRoot, {
+        port: props.port,
+        // If a scheme is specified then use that instead of the package name.
+        scheme: (_this = await (0, _scheme.getSchemesForAndroidAsync)(projectRoot)) == null ? void 0 : _this[0],
+        headless: !props.shouldStartBundler
+    });
+    if (!options.binary) {
+        // Find the APK file path
+        const apkFile = await (0, _resolveInstallApkName.resolveInstallApkNameAsync)(props.device.device, props);
+        if (apkFile) {
+            // Attempt to install the APK from the file path
+            options.binary = _path().default.join(props.apkVariantDirectory, apkFile);
+        }
+    }
+    if (options.binary) {
+        // Attempt to install the APK from the file path
+        const binaryPath = _path().default.join(options.binary);
+        if (!_fs().default.existsSync(binaryPath)) {
+            throw new _errors.CommandError(`The path to the custom Android binary does not exist: ${binaryPath}`);
+        }
+        _log.Log.log(_chalk().default.gray`\u203A Installing ${binaryPath}`);
+        await props.device.installAppAsync(binaryPath);
+    } else {
+        await installAppAsync(androidProjectRoot, props);
+    }
+    await manager.getDefaultDevServer().openCustomRuntimeAsync('emulator', {
+        applicationId: props.packageName,
+        customAppId: props.customAppId,
+        launchActivity: props.launchActivity
+    }, {
+        device: props.device.device
+    });
+    if (props.shouldStartBundler) {
+        (0, _hints.logProjectLogsLocation)();
+    } else {
+        await manager.stopAsync();
+    }
+    if (options.binary && shouldUpdateBuildCache && props.buildCacheProvider) {
+        await (0, _buildcacheproviders.uploadBuildCache)({
+            projectRoot,
+            platform: 'android',
+            provider: props.buildCacheProvider,
+            buildPath: options.binary,
+            runOptions: options
+        });
+    }
+}
+async function installAppAsync(androidProjectRoot, props) {
+    // If we cannot resolve the APK file path then we can attempt to install using Gradle.
+    // This offers more advanced resolution that we may not have first class support for.
+    _log.Log.log('› Failed to locate binary file, installing with Gradle...');
+    await (0, _gradle.installAsync)(androidProjectRoot, {
+        variant: props.variant ?? 'debug',
+        appName: props.appName ?? 'app',
+        port: props.port
+    });
+}
+
+//# sourceMappingURL=runAndroidAsync.js.map

package/build/src/run/android/runAndroidAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/runAndroidAsync.ts"],"sourcesContent":["import chalk from 'chalk';\nimport fs from 'fs';\nimport path from 'path';\n\nimport { resolveInstallApkNameAsync } from './resolveInstallApkName';\nimport { Options, ResolvedOptions, resolveOptionsAsync } from './resolveOptions';\nimport { exportEagerAsync } from '../../export/embed/exportEager';\nimport { Log } from '../../log';\nimport type { AndroidOpenInCustomProps } from '../../start/platforms/android/AndroidPlatformManager';\nimport { assembleAsync, installAsync } from '../../start/platforms/android/gradle';\nimport { resolveBuildCache, uploadBuildCache } from '../../utils/build-cache-providers';\nimport { CommandError } from '../../utils/errors';\nimport { setNodeEnv, loadEnvFiles } from '../../utils/nodeEnv';\nimport { ensurePortAvailabilityAsync } from '../../utils/port';\nimport { getSchemesForAndroidAsync } from '../../utils/scheme';\nimport { ensureNativeProjectAsync } from '../ensureNativeProject';\nimport { logProjectLogsLocation } from '../hints';\nimport { startBundlerAsync } from '../startBundler';\n\nconst debug = require('debug')('expo:run:android');\n\nexport async function runAndroidAsync(projectRoot: string, { install, ...options }: Options) {\n  // NOTE: This is a guess, the developer can overwrite with `NODE_ENV`.\n  const isProduction = options.variant?.toLowerCase().endsWith('release');\n  setNodeEnv(isProduction ? 'production' : 'development');\n  loadEnvFiles(projectRoot);\n\n  await ensureNativeProjectAsync(projectRoot, { platform: 'android', install });\n\n  const props = await resolveOptionsAsync(projectRoot, options);\n\n  if (!options.binary && props.buildCacheProvider) {\n    const localPath = await resolveBuildCache({\n      projectRoot,\n      platform: 'android',\n      provider: props.buildCacheProvider,\n      runOptions: options,\n    });\n    if (localPath) {\n      options.binary = localPath;\n    }\n  }\n\n  debug('Package name: ' + props.packageName);\n  Log.log('› Building app...');\n\n  const androidProjectRoot = path.join(projectRoot, 'android');\n\n  let shouldUpdateBuildCache = false;\n  if (!options.binary) {\n    let eagerBundleOptions: string | undefined;\n\n    if (isProduction) {\n      eagerBundleOptions = JSON.stringify(\n        await exportEagerAsync(projectRoot, {\n          dev: false,\n          platform: 'android',\n        })\n      );\n    }\n\n    await assembleAsync(androidProjectRoot, {\n      variant: props.variant,\n      port: props.port,\n      appName: props.appName,\n      buildCache: props.buildCache,\n      architectures: props.architectures,\n      eagerBundleOptions,\n    });\n    shouldUpdateBuildCache = true;\n\n    // Ensure the port hasn't become busy during the build.\n    if (props.shouldStartBundler && !(await ensurePortAvailabilityAsync(projectRoot, props))) {\n      props.shouldStartBundler = false;\n    }\n  }\n\n  const manager = await startBundlerAsync(projectRoot, {\n    port: props.port,\n    // If a scheme is specified then use that instead of the package name.\n    scheme: (await getSchemesForAndroidAsync(projectRoot))?.[0],\n    headless: !props.shouldStartBundler,\n  });\n\n  if (!options.binary) {\n    // Find the APK file path\n    const apkFile = await resolveInstallApkNameAsync(props.device.device, props);\n    if (apkFile) {\n      // Attempt to install the APK from the file path\n      options.binary = path.join(props.apkVariantDirectory, apkFile);\n    }\n  }\n\n  if (options.binary) {\n    // Attempt to install the APK from the file path\n    const binaryPath = path.join(options.binary);\n\n    if (!fs.existsSync(binaryPath)) {\n      throw new CommandError(`The path to the custom Android binary does not exist: ${binaryPath}`);\n    }\n    Log.log(chalk.gray`\\u203A Installing ${binaryPath}`);\n    await props.device.installAppAsync(binaryPath);\n  } else {\n    await installAppAsync(androidProjectRoot, props);\n  }\n\n  await manager.getDefaultDevServer().openCustomRuntimeAsync<AndroidOpenInCustomProps>(\n    'emulator',\n    {\n      applicationId: props.packageName,\n      customAppId: props.customAppId,\n      launchActivity: props.launchActivity,\n    },\n    { device: props.device.device }\n  );\n\n  if (props.shouldStartBundler) {\n    logProjectLogsLocation();\n  } else {\n    await manager.stopAsync();\n  }\n\n  if (options.binary && shouldUpdateBuildCache && props.buildCacheProvider) {\n    await uploadBuildCache({\n      projectRoot,\n      platform: 'android',\n      provider: props.buildCacheProvider,\n      buildPath: options.binary,\n      runOptions: options,\n    });\n  }\n}\n\nasync function installAppAsync(androidProjectRoot: string, props: ResolvedOptions) {\n  // If we cannot resolve the APK file path then we can attempt to install using Gradle.\n  // This offers more advanced resolution that we may not have first class support for.\n  Log.log('› Failed to locate binary file, installing with Gradle...');\n  await installAsync(androidProjectRoot, {\n    variant: props.variant ?? 'debug',\n    appName: props.appName ?? 'app',\n    port: props.port,\n  });\n}\n"],"names":["runAndroidAsync","debug","require","projectRoot","install","options","isProduction","variant","toLowerCase","endsWith","setNodeEnv","loadEnvFiles","ensureNativeProjectAsync","platform","props","resolveOptionsAsync","binary","buildCacheProvider","localPath","resolveBuildCache","provider","runOptions","packageName","Log","log","androidProjectRoot","path","join","shouldUpdateBuildCache","eagerBundleOptions","JSON","stringify","exportEagerAsync","dev","assembleAsync","port","appName","buildCache","architectures","shouldStartBundler","ensurePortAvailabilityAsync","manager","startBundlerAsync","scheme","getSchemesForAndroidAsync","headless","apkFile","resolveInstallApkNameAsync","device","apkVariantDirectory","binaryPath","fs","existsSync","CommandError","chalk","gray","installAppAsync","getDefaultDevServer","openCustomRuntimeAsync","applicationId","customAppId","launchActivity","logProjectLogsLocation","stopAsync","uploadBuildCache","buildPath","installAsync"],"mappings":";;;;+BAqBsBA;;;eAAAA;;;;gEArBJ;;;;;;;gEACH;;;;;;;gEACE;;;;;;uCAE0B;gCACmB;6BAC7B;qBACb;wBAEwB;qCACQ;wBACvB;yBACY;sBACG;wBACF;qCACD;uBACF;8BACL;;;;;;AAElC,MAAMC,QAAQC,QAAQ,SAAS;AAExB,eAAeF,gBAAgBG,WAAmB,EAAE,EAAEC,OAAO,EAAE,GAAGC,SAAkB;QAEpEA,kBAyDV;IA1DX,sEAAsE;IACtE,MAAMC,gBAAeD,mBAAAA,QAAQE,OAAO,qBAAfF,iBAAiBG,WAAW,GAAGC,QAAQ,CAAC;IAC7DC,IAAAA,mBAAU,EAACJ,eAAe,eAAe;IACzCK,IAAAA,qBAAY,EAACR;IAEb,MAAMS,IAAAA,6CAAwB,EAACT,aAAa;QAAEU,UAAU;QAAWT;IAAQ;IAE3E,MAAMU,QAAQ,MAAMC,IAAAA,mCAAmB,EAACZ,aAAaE;IAErD,IAAI,CAACA,QAAQW,MAAM,IAAIF,MAAMG,kBAAkB,EAAE;QAC/C,MAAMC,YAAY,MAAMC,IAAAA,sCAAiB,EAAC;YACxChB;YACAU,UAAU;YACVO,UAAUN,MAAMG,kBAAkB;YAClCI,YAAYhB;QACd;QACA,IAAIa,WAAW;YACbb,QAAQW,MAAM,GAAGE;QACnB;IACF;IAEAjB,MAAM,mBAAmBa,MAAMQ,WAAW;IAC1CC,QAAG,CAACC,GAAG,CAAC;IAER,MAAMC,qBAAqBC,eAAI,CAACC,IAAI,CAACxB,aAAa;IAElD,IAAIyB,yBAAyB;IAC7B,IAAI,CAACvB,QAAQW,MAAM,EAAE;QACnB,IAAIa;QAEJ,IAAIvB,cAAc;YAChBuB,qBAAqBC,KAAKC,SAAS,CACjC,MAAMC,IAAAA,6BAAgB,EAAC7B,aAAa;gBAClC8B,KAAK;gBACLpB,UAAU;YACZ;QAEJ;QAEA,MAAMqB,IAAAA,qBAAa,EAACT,oBAAoB;YACtClB,SAASO,MAAMP,OAAO;YACtB4B,MAAMrB,MAAMqB,IAAI;YAChBC,SAAStB,MAAMsB,OAAO;YACtBC,YAAYvB,MAAMuB,UAAU;YAC5BC,eAAexB,MAAMwB,aAAa;YAClCT;QACF;QACAD,yBAAyB;QAEzB,uDAAuD;QACvD,IAAId,MAAMyB,kBAAkB,IAAI,CAAE,MAAMC,IAAAA,iCAA2B,EAACrC,aAAaW,QAAS;YACxFA,MAAMyB,kBAAkB,GAAG;QAC7B;IACF;IAEA,MAAME,UAAU,MAAMC,IAAAA,+BAAiB,EAACvC,aAAa;QACnDgC,MAAMrB,MAAMqB,IAAI;QAChB,sEAAsE;QACtEQ,MAAM,GAAG,QAAA,MAAMC,IAAAA,iCAAyB,EAACzC,iCAAjC,AAAC,KAA+C,CAAC,EAAE;QAC3D0C,UAAU,CAAC/B,MAAMyB,kBAAkB;IACrC;IAEA,IAAI,CAAClC,QAAQW,MAAM,EAAE;QACnB,yBAAyB;QACzB,MAAM8B,UAAU,MAAMC,IAAAA,iDAA0B,EAACjC,MAAMkC,MAAM,CAACA,MAAM,EAAElC;QACtE,IAAIgC,SAAS;YACX,gDAAgD;YAChDzC,QAAQW,MAAM,GAAGU,eAAI,CAACC,IAAI,CAACb,MAAMmC,mBAAmB,EAAEH;QACxD;IACF;IAEA,IAAIzC,QAAQW,MAAM,EAAE;QAClB,gDAAgD;QAChD,MAAMkC,aAAaxB,eAAI,CAACC,IAAI,CAACtB,QAAQW,MAAM;QAE3C,IAAI,CAACmC,aAAE,CAACC,UAAU,CAACF,aAAa;YAC9B,MAAM,IAAIG,oBAAY,CAAC,CAAC,sDAAsD,EAAEH,YAAY;QAC9F;QACA3B,QAAG,CAACC,GAAG,CAAC8B,gBAAK,CAACC,IAAI,CAAC,kBAAkB,EAAEL,WAAW,CAAC;QACnD,MAAMpC,MAAMkC,MAAM,CAACQ,eAAe,CAACN;IACrC,OAAO;QACL,MAAMM,gBAAgB/B,oBAAoBX;IAC5C;IAEA,MAAM2B,QAAQgB,mBAAmB,GAAGC,sBAAsB,CACxD,YACA;QACEC,eAAe7C,MAAMQ,WAAW;QAChCsC,aAAa9C,MAAM8C,WAAW;QAC9BC,gBAAgB/C,MAAM+C,cAAc;IACtC,GACA;QAAEb,QAAQlC,MAAMkC,MAAM,CAACA,MAAM;IAAC;IAGhC,IAAIlC,MAAMyB,kBAAkB,EAAE;QAC5BuB,IAAAA,6BAAsB;IACxB,OAAO;QACL,MAAMrB,QAAQsB,SAAS;IACzB;IAEA,IAAI1D,QAAQW,MAAM,IAAIY,0BAA0Bd,MAAMG,kBAAkB,EAAE;QACxE,MAAM+C,IAAAA,qCAAgB,EAAC;YACrB7D;YACAU,UAAU;YACVO,UAAUN,MAAMG,kBAAkB;YAClCgD,WAAW5D,QAAQW,MAAM;YACzBK,YAAYhB;QACd;IACF;AACF;AAEA,eAAemD,gBAAgB/B,kBAA0B,EAAEX,KAAsB;IAC/E,sFAAsF;IACtF,qFAAqF;IACrFS,QAAG,CAACC,GAAG,CAAC;IACR,MAAM0C,IAAAA,oBAAY,EAACzC,oBAAoB;QACrClB,SAASO,MAAMP,OAAO,IAAI;QAC1B6B,SAAStB,MAAMsB,OAAO,IAAI;QAC1BD,MAAMrB,MAAMqB,IAAI;IAClB;AACF"}