7214

Committed 06 Oct 2023 02:44AM UTC coverage: 60.05% (-0.3%) from 60.393%

Build # 7214

Build Type

push

Azure Pipelines

Committed by

web-flow

Commit Message

Merge pull request #1902 from Karthiccc23/add-pod-update

Add optional podRepoUpdate flag in iosConfig

Run Details

3790 of 7668 branches covered (49.43%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

51 existing lines in 5 files now uncovered.

9908 of 15143 relevant lines covered (65.43%)

551.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.12

/ern-core/src/android.ts

import fs from 'fs-extra';
import inquirer from 'inquirer';
import shell from './shell';
import ernConfig from './config';
import * as deviceConfigUtil from './deviceConfig';
import log from './log';
import { execp, spawnp } from './childProcess';
import kax from './kax';
import semver from 'semver';

// ==============================================================================
// Default value for android build config
// ==============================================================================

export const DEFAULT_ANDROID_GRADLE_PLUGIN_VERSION = '7.0.4';
export const DEFAULT_ANDROIDX_APPCOMPACT_VERSION = '1.1.0';
export const DEFAULT_ANDROIDX_LIFECYCLE_EXTENSIONS_VERSION = '2.1.0';
export const DEFAULT_BUILD_TOOLS_VERSION = '31.0.0';
export const DEFAULT_COMPILE_SDK_VERSION = '31';
export const DEFAULT_GRADLE_DISTRIBUTION_VERSION = '7.3.3';
export const DEFAULT_JSC_VARIANT = 'android-jsc';
export const DEFAULT_KOTLIN_VERSION = '1.6.10';
export const DEFAULT_MIN_SDK_VERSION_PRE_RN64 = '19';
export const DEFAULT_MIN_SDK_VERSION_POST_RN64 = '21';
export const DEFAULT_SUPPORT_LIBRARY_VERSION = '28.0.0';
export const DEFAULT_TARGET_SDK_VERSION = '30';
export const DEFAULT_SOURCE_COMPATIBILITY = 'VERSION_1_8';
export const DEFAULT_TARGET_COMPATIBILITY = 'VERSION_1_8';
const ANDROID_DEVICE_INFO = `
https://developer.android.com/studio/run/emulator-commandline
https://developer.android.com/studio/run/emulator`;

export interface AndroidResolvedVersions {
  androidGradlePlugin: string;
  androidxAppcompactVersion: string;
  androidxLifecycleExtrnsionsVersion: string;
  buildToolsVersion: string;
  compileSdkVersion: string;
  gradleDistributionVersion: string;
  kotlinVersion: string;
  minSdkVersion: string;
  reactNativeAarVersion: string;
  sourceCompatibility: string;
  supportLibraryVersion: string;
  targetCompatibility: string;
  targetSdkVersion: string;
}

export function resolveAndroidVersions({
  androidGradlePlugin = DEFAULT_ANDROID_GRADLE_PLUGIN_VERSION,
  androidxAppcompactVersion = DEFAULT_ANDROIDX_APPCOMPACT_VERSION,
  androidxLifecycleExtrnsionsVersion = DEFAULT_ANDROIDX_LIFECYCLE_EXTENSIONS_VERSION,
  buildToolsVersion = DEFAULT_BUILD_TOOLS_VERSION,
  compileSdkVersion = DEFAULT_COMPILE_SDK_VERSION,
  gradleDistributionVersion = DEFAULT_GRADLE_DISTRIBUTION_VERSION,
  kotlinVersion = DEFAULT_KOTLIN_VERSION,
  minSdkVersion,
  reactNativeAarVersion,
  sourceCompatibility = DEFAULT_SOURCE_COMPATIBILITY,
  supportLibraryVersion = DEFAULT_SUPPORT_LIBRARY_VERSION,
  targetCompatibility = DEFAULT_TARGET_COMPATIBILITY,
  targetSdkVersion = DEFAULT_TARGET_SDK_VERSION,
  reactNativeVersion,
}: {
  androidGradlePlugin?: string;
  androidxAppcompactVersion?: string;
  androidxLifecycleExtrnsionsVersion?: string;
  buildToolsVersion?: string;
  compileSdkVersion?: string;
  gradleDistributionVersion?: string;
  kotlinVersion?: string;
  minSdkVersion?: string;
  reactNativeAarVersion?: string;
  sourceCompatibility?: string;
  supportLibraryVersion?: string;
  targetCompatibility?: string;
  targetSdkVersion?: string;
  reactNativeVersion?: string;
} = {}): AndroidResolvedVersions {
  const resolvedMinSdkVersion = minSdkVersion
    ? minSdkVersion
    : semver.gte(reactNativeVersion!, '0.64.0')
    ? DEFAULT_MIN_SDK_VERSION_POST_RN64
    : DEFAULT_MIN_SDK_VERSION_PRE_RN64;

  reactNativeAarVersion = reactNativeAarVersion ?? reactNativeVersion!;

  return {
    androidGradlePlugin,
    androidxAppcompactVersion,
    androidxLifecycleExtrnsionsVersion,
    buildToolsVersion,
    compileSdkVersion,
    gradleDistributionVersion,
    kotlinVersion,
    minSdkVersion: resolvedMinSdkVersion,
    reactNativeAarVersion,
    sourceCompatibility,
    supportLibraryVersion,
    targetCompatibility,
    targetSdkVersion,
  };
}

// ==============================================================================
// Misc utilities
// ==============================================================================

// Returns a promise that will get resolved after a given delay (in ms)
async function delay(ms: number) {
  return new Promise<void>((resolve, reject) => {
    setTimeout(() => {
      resolve();
    }, ms);
  });
}

// Returns a promise that will get rejected after a given timeout (in ms)
async function failAfterTimeOut(ms: number) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      reject(
        new Error(
          `Failed to collect the device/emulator state.${ANDROID_DEVICE_INFO}`,
        ),
      );
    }, ms);
  });
}

// ==============================================================================
// Core android stuff
// ==============================================================================

//
// Build and run a project on an Android emulator or connected device
// The `devDebug` variant will be built and launched on an emulator selected by
// the user (this function prompts the user with a list of available avd to choose from)
//
// Assumptions :
// - devDebug variant exists in the project
// Params :
// - activityName : The name of the Activity to start (default "MainActivity")
// - launchFlags: Flags to pass to the application when launching it
// - packageName : Name of the package containing the application
// Options :
// - projectPath : Absolute or relative path to the root of the Android projectPath

export async function runAndroidProject({
  activityName = 'MainActivity',
  launchFlags,
  packageName,
  projectPath,
}: {
  activityName?: string;
  launchFlags?: string;
  packageName: string;
  projectPath: string;
}) {
  return runAndroid({
    activityName,
    launchFlags,
    packageName,
    projectPath,
  });
}

//
// Run an android APK on an Android emulator or connected device
//
// Params :
// - apkPath : Absolute or relative path to the APK
// - packageName : Name of the package containing the application
// Options :
// - activityName : The name of the Activity to start (default "MainActivity")
export async function runAndroidApk({
  activityName = 'MainActivity',
  apkPath,
  launchFlags,
  packageName,
}: {
  activityName?: string;
  apkPath: string;
  launchFlags?: string;
  packageName: string;
}) {
  return runAndroid({
    activityName,
    apkPath,
    launchFlags,
    packageName,
  });
}

export async function runAndroid({
  activityName,
  apkPath,
  launchFlags,
  packageName,
  projectPath,
}: {
  activityName: string;
  apkPath?: string;
  launchFlags?: string;
  packageName: string;

  projectPath?: string;
}) {
  const devices = await getDevices();
  // install and launch the app if 1 emulator instance is running
  if (devices.length === 1) {
    log.debug(`${devices[0].split('\t')[0]} is running ...`);
    await installAndLaunchApp({
      activityName,
      apkPath,
      launchFlags,
      packageName,
      projectPath,
    });
  } else if (devices.length > 1) {
    throw new Error('More than one device/emulator is running !');
  } else {
    const avdImageName = await askUserToSelectAvdEmulator();
    return runAndroidUsingAvdImage({
      activityName,
      apkPath,
      avdImageName,
      launchFlags,
      packageName,
      projectPath,
    });
  }
}

export async function askUserToSelectAvdEmulator(): Promise<string> {
  const avdImageNames = await getAndroidAvds();
  if (Array.isArray(avdImageNames) && avdImageNames.length === 0) {
    throw new Error(
      `No Emulator or device found. Launch an emulator manually or connect a device.${ANDROID_DEVICE_INFO}`,
    );
  }
  const deviceConfig = ernConfig.get(deviceConfigUtil.ANDROID_DEVICE_CONFIG);
  // Check if user has set the usePreviousEmulator flag to true
  if (avdImageNames && deviceConfig) {
    if (deviceConfig.usePreviousDevice) {
      // Get the name of previously used device
      const deviceId = deviceConfig.deviceId;
      // Check if avd image still exists
      const avdIndex = avdImageNames.indexOf(deviceId);
      if (avdIndex > -1) {
        return `${avdImageNames[avdIndex]}`;
      }
    }
  }

  // if avd image is still not resolved
  const { avdImageName } = await inquirer.prompt([
    <inquirer.Question>{
      choices: avdImageNames,
      message: 'Choose Android device image',
      name: 'avdImageName',
      type: 'list',
    },
  ]);

  // Update the device Config
  if (deviceConfig) {
    deviceConfig.deviceId = avdImageName;
    ernConfig.set(deviceConfigUtil.ANDROID_DEVICE_CONFIG, deviceConfig);
  }
  return `${avdImageName}`;
}

// Does the job of actually running the app
// It orchestrates a few tasks to actually get the job done
// Params :
// - projectPath : Absolute or relative path to the root of the Android projectPath
// - packageName : name of the package containing the application
// - avdImageName : name of the avd image to use (device image)
export async function runAndroidUsingAvdImage({
  activityName,
  apkPath,
  launchFlags,
  avdImageName,
  packageName,
  projectPath,
}: {
  activityName: string;
  apkPath?: string;
  avdImageName: string;
  launchFlags?: string;
  packageName: string;
  projectPath?: string;
}) {
  // https://issuetracker.google.com/issues/37137213
  spawnp(androidEmulatorPath(), ['-avd', avdImageName], { detached: true });
  await kax
    .task('Waiting for device to start')
    .run(
      Promise.race([waitForAndroidDevice(), failAfterTimeOut(3 * 60 * 1000)]),
    );
  await installAndLaunchApp({
    activityName,
    apkPath,
    launchFlags,
    packageName,
    projectPath,
  });
}

// Does the job of installing and running the app
// It orchestrates a few tasks to actually get the job done
// Params :
// - projectPath : Absolute or relative path to the root of the Android projectPath
// - packageName : name of the package containing the application
export async function installAndLaunchApp({
  activityName,
  apkPath,
  launchFlags,
  packageName,
  projectPath,
}: {
  activityName: string;
  apkPath?: string;
  launchFlags?: string;
  packageName: string;
  projectPath?: string;
}) {
  if (projectPath) {
    await kax
      .task('Building and installing application')
      .run(buildAndInstallApp(projectPath));
  } else if (apkPath) {
    await kax.task('Installing APK').run(installApk(apkPath));
  }
  await kax.task('Launching Android Application').run(Promise.resolve());
  launchAndroidActivityDetached(packageName, activityName, { launchFlags });
}

// Utility method that basically completes whenever the android device is ready
// It check device readiness every 2 sec (poll way)
export async function waitForAndroidDevice() {
  let androidBootAnimProp = await androidGetBootAnimProp();
  while (!androidBootAnimProp.toString().startsWith('stopped')) {
    await delay(2000);
    androidBootAnimProp = await androidGetBootAnimProp();
  }
}

// Utility method to know when the prop init.svc.bootanim is there
// which indicates somehow that device is ready to install APK and such
export async function androidGetBootAnimProp() {
  return execp(
    `${androidAdbPath()} wait-for-device shell getprop init.svc.bootanim`,
  );
}

// Build & install application on the device
// params :
// - projectPath : Absolute or relative path to the root of the Android project
// containing the application
export async function buildAndInstallApp(projectPath: string) {
  shell.pushd(projectPath);
  try {
    const gradlew = getGradleByPlatform();
    return execp(`${gradlew} installDebug`);
  } finally {
    shell.popd();
  }
}

export function getGradleByPlatform(): string {
  return /^win/.test(process.platform) ? 'gradlew' : './gradlew';
}

// Utility method to launch a specific activity from a given package
// Params :
// - packageName : name of the package containing the application
// - activityName : name of the Activity to launch
export async function launchAndroidActivity(
  packageName: string,
  activityName: string,
) {
  return execp(
    `${androidAdbPath()} shell am start -n ${packageName}/.${activityName}`,
  );
}

// Utility method to launch a specific activity from a given packager
// Will spawn the command (detached mode)
export function launchAndroidActivityDetached(
  packageName: string,
  activityName: string,
  { launchFlags = '' }: { launchFlags?: string } = {},
) {
  spawnp(
    androidAdbPath(),
    [
      'shell',
      'am',
      'start',
      '-n',
      `${packageName}/.${activityName}`,
      launchFlags,
    ],
    { detached: true },
  );
}

// Utility method to list all available android avd images (emulator images)
export async function getAndroidAvds() {
  const stdout = await execp(`${androidEmulatorPath()} -list-avds`);
  let avdArr: string[] = [];
  if (stdout) {
    avdArr = stdout.toString().trim().split(/\r?\n/);
  }
  return avdArr;
}

// Utility method to query what device instances are connected to the adb server
export async function getDevices(): Promise<string[]> {
  const stdout = await execp(`${androidAdbPath()} devices`);
  /*
    stdout for running command  $adb devices
    List of devices attached
    * daemon not running. starting it now at tcp:5037 *
    * daemon started successfully *
  */
  const stdOutArr = stdout.toString().trim().split(/\r?\n/);
  // remove stdout 'List of devices attached' (position 0)
  // and remove stdout related to daemon
  return stdOutArr.filter((entry, i) => i > 0 && !entry.includes('* daemon'));
}

export async function installApk(pathToApk: string) {
  return execp(`${androidAdbPath()} install -r ${pathToApk}`);
}

export function androidSdkRoot(): string | undefined {
  return process.env.ANDROID_SDK_ROOT ?? process.env.ANDROID_HOME;
}

export function androidAdbPath(): string {
  const sdkRoot = androidSdkRoot();
  return sdkRoot ? `${sdkRoot}/platform-tools/adb` : 'adb';
}

export function androidEmulatorPath(): string {
  const sdkRoot = androidSdkRoot();
  if (sdkRoot) {
    if (fs.existsSync(`${sdkRoot}/emulator/emulator`)) {
      return `${sdkRoot}/emulator/emulator`;
    }
    if (fs.existsSync(`${sdkRoot}/tools/emulator`)) {
      return `${sdkRoot}/tools/emulator`;
    }
  }
  return 'emulator';
}

/**
 * Returns the default Hermes engine (hermes-engine) package version used by a given React Native version.
 * Only works for versions of RN >= 0.60.0 as hermes-engine package was introduced in this version.
 */
export function getDefaultHermesVersion(
  reactNativeVersion: string,
): string | never {
  if (semver.gte(reactNativeVersion, '0.66.0')) {
    // https://github.com/facebook/react-native/blob/v0.66.0/package.json#L98
    return '~0.9.0';
  } else if (semver.gte(reactNativeVersion, '0.65.0')) {
    // https://github.com/facebook/react-native/blob/v0.65.0/package.json#L98
    return '~0.8.1';
  } else if (semver.gte(reactNativeVersion, '0.64.0')) {
    // https://github.com/facebook/react-native/blob/v0.64.0/package.json#L97
    return '~0.7.0';
  } else if (semver.gte(reactNativeVersion, '0.63.0')) {
    // https://github.com/facebook/react-native/blob/v0.63.0/package.json#L98
    return '~0.5.0';
  } else if (semver.gte(reactNativeVersion, '0.62.0')) {
    return '~0.4.0';
  } else if (semver.gte(reactNativeVersion, '0.60.0')) {
    return '^0.2.1';
  } else {
    throw new Error(
      'This function can only be called for versions of React Native >= 0.60.0',
    );
  }
}

/**
 * Returns the default JavaScriptCore engine version used
 * by a given React Native version.
 * Only works for versions of RN >= 0.60.0 as dynamic jsc-android
 * package was introduced in this version.
 */
export function getDefaultJSCVersion(
  reactNativeVersion: string,
): string | never {
  if (semver.gte(reactNativeVersion, '0.65.0')) {
    return '^250230.2.1';
  } else if (semver.gte(reactNativeVersion, '0.61.0')) {
    return '^245459.0.0';
  } else if (semver.gte(reactNativeVersion, '0.60.0')) {
    return '245459.0.0';
  } else {
    throw new Error(
      'This function can only be called for versions of React Native >= 0.60.0',
    );
  }
}

1	import fs from 'fs-extra';	24✔
2	import inquirer from 'inquirer';	24✔
3	import shell from './shell';	24✔
4	import ernConfig from './config';	24✔
5	import * as deviceConfigUtil from './deviceConfig';	24✔
6	import log from './log';	24✔
7	import { execp, spawnp } from './childProcess';	24✔
8	import kax from './kax';	24✔
9	import semver from 'semver';	24✔
10
11	// ==============================================================================
12	// Default value for android build config
13	// ==============================================================================
14
15	export const DEFAULT_ANDROID_GRADLE_PLUGIN_VERSION = '7.0.4';	24✔
16	export const DEFAULT_ANDROIDX_APPCOMPACT_VERSION = '1.1.0';	24✔
17	export const DEFAULT_ANDROIDX_LIFECYCLE_EXTENSIONS_VERSION = '2.1.0';	24✔
18	export const DEFAULT_BUILD_TOOLS_VERSION = '31.0.0';	24✔
19	export const DEFAULT_COMPILE_SDK_VERSION = '31';	24✔
20	export const DEFAULT_GRADLE_DISTRIBUTION_VERSION = '7.3.3';	24✔
21	export const DEFAULT_JSC_VARIANT = 'android-jsc';	24✔
22	export const DEFAULT_KOTLIN_VERSION = '1.6.10';	24✔
23	export const DEFAULT_MIN_SDK_VERSION_PRE_RN64 = '19';	24✔
24	export const DEFAULT_MIN_SDK_VERSION_POST_RN64 = '21';	24✔
25	export const DEFAULT_SUPPORT_LIBRARY_VERSION = '28.0.0';	24✔
26	export const DEFAULT_TARGET_SDK_VERSION = '30';	24✔
27	export const DEFAULT_SOURCE_COMPATIBILITY = 'VERSION_1_8';	24✔
28	export const DEFAULT_TARGET_COMPATIBILITY = 'VERSION_1_8';	24✔
29	const ANDROID_DEVICE_INFO = `	24✔
30	https://developer.android.com/studio/run/emulator-commandline
31	https://developer.android.com/studio/run/emulator`;
32
33	export interface AndroidResolvedVersions {
34	androidGradlePlugin: string;
35	androidxAppcompactVersion: string;
36	androidxLifecycleExtrnsionsVersion: string;
37	buildToolsVersion: string;
38	compileSdkVersion: string;
39	gradleDistributionVersion: string;
40	kotlinVersion: string;
41	minSdkVersion: string;
42	reactNativeAarVersion: string;
43	sourceCompatibility: string;
44	supportLibraryVersion: string;
45	targetCompatibility: string;
46	targetSdkVersion: string;
47	}
48
49	export function resolveAndroidVersions({	24✔
50	androidGradlePlugin = DEFAULT_ANDROID_GRADLE_PLUGIN_VERSION,	6✔
51	androidxAppcompactVersion = DEFAULT_ANDROIDX_APPCOMPACT_VERSION,	9✔
52	androidxLifecycleExtrnsionsVersion = DEFAULT_ANDROIDX_LIFECYCLE_EXTENSIONS_VERSION,	9✔
53	buildToolsVersion = DEFAULT_BUILD_TOOLS_VERSION,	9✔
54	compileSdkVersion = DEFAULT_COMPILE_SDK_VERSION,	9✔
55	gradleDistributionVersion = DEFAULT_GRADLE_DISTRIBUTION_VERSION,	9✔
56	kotlinVersion = DEFAULT_KOTLIN_VERSION,	8✔
57	minSdkVersion,
58	reactNativeAarVersion,
59	sourceCompatibility = DEFAULT_SOURCE_COMPATIBILITY,	8✔
60	supportLibraryVersion = DEFAULT_SUPPORT_LIBRARY_VERSION,	9✔
61	targetCompatibility = DEFAULT_TARGET_COMPATIBILITY,	8✔
62	targetSdkVersion = DEFAULT_TARGET_SDK_VERSION,	9✔
63	reactNativeVersion,
64	}: {
65	androidGradlePlugin?: string;
66	androidxAppcompactVersion?: string;
67	androidxLifecycleExtrnsionsVersion?: string;
68	buildToolsVersion?: string;
69	compileSdkVersion?: string;
70	gradleDistributionVersion?: string;
71	kotlinVersion?: string;
72	minSdkVersion?: string;
73	reactNativeAarVersion?: string;
74	sourceCompatibility?: string;
75	supportLibraryVersion?: string;
76	targetCompatibility?: string;
77	targetSdkVersion?: string;
78	reactNativeVersion?: string;
79	} = {}): AndroidResolvedVersions {	×
80	const resolvedMinSdkVersion = minSdkVersion	10✔
81	? minSdkVersion	10✔
82	: semver.gte(reactNativeVersion!, '0.64.0')
83	? DEFAULT_MIN_SDK_VERSION_POST_RN64	8✔
84	: DEFAULT_MIN_SDK_VERSION_PRE_RN64;
85
86	reactNativeAarVersion = reactNativeAarVersion ?? reactNativeVersion!;	10!
87
88	return {	10✔
89	androidGradlePlugin,
90	androidxAppcompactVersion,
91	androidxLifecycleExtrnsionsVersion,
92	buildToolsVersion,
93	compileSdkVersion,
94	gradleDistributionVersion,
95	kotlinVersion,
96	minSdkVersion: resolvedMinSdkVersion,
97	reactNativeAarVersion,
98	sourceCompatibility,
99	supportLibraryVersion,
100	targetCompatibility,
101	targetSdkVersion,
102	};
103	}
104
105	// ==============================================================================
106	// Misc utilities
107	// ==============================================================================
108
109	// Returns a promise that will get resolved after a given delay (in ms)
110	async function delay(ms: number) {
111	return new Promise<void>((resolve, reject) => {	×
112	setTimeout(() => {	×
113	resolve();	×
114	}, ms);
115	});
116	}
117
118	// Returns a promise that will get rejected after a given timeout (in ms)
119	async function failAfterTimeOut(ms: number) {
120	return new Promise((resolve, reject) => {	×
121	setTimeout(() => {	×
122	reject(	×
123	new Error(
124	`Failed to collect the device/emulator state.${ANDROID_DEVICE_INFO}`,
125	),
126	);
127	}, ms);
128	});
129	}
130
131	// ==============================================================================
132	// Core android stuff
133	// ==============================================================================
134
135	//
136	// Build and run a project on an Android emulator or connected device
137	// The `devDebug` variant will be built and launched on an emulator selected by
138	// the user (this function prompts the user with a list of available avd to choose from)
139	//
140	// Assumptions :
141	// - devDebug variant exists in the project
142	// Params :
143	// - activityName : The name of the Activity to start (default "MainActivity")
144	// - launchFlags: Flags to pass to the application when launching it
145	// - packageName : Name of the package containing the application
146	// Options :
147	// - projectPath : Absolute or relative path to the root of the Android projectPath
148
149	export async function runAndroidProject({	24✔
150	activityName = 'MainActivity',	×
151	launchFlags,
152	packageName,
153	projectPath,
154	}: {
155	activityName?: string;
156	launchFlags?: string;
157	packageName: string;
158	projectPath: string;
159	}) {
160	return runAndroid({	×
161	activityName,
162	launchFlags,
163	packageName,
164	projectPath,
165	});
166	}
167
168	//
169	// Run an android APK on an Android emulator or connected device
170	//
171	// Params :
172	// - apkPath : Absolute or relative path to the APK
173	// - packageName : Name of the package containing the application
174	// Options :
175	// - activityName : The name of the Activity to start (default "MainActivity")
176	export async function runAndroidApk({	24✔
177	activityName = 'MainActivity',	×
178	apkPath,
179	launchFlags,
180	packageName,
181	}: {
182	activityName?: string;
183	apkPath: string;
184	launchFlags?: string;
185	packageName: string;
186	}) {
187	return runAndroid({	×
188	activityName,
189	apkPath,
190	launchFlags,
191	packageName,
192	});
193	}
194
195	export async function runAndroid({	24✔
196	activityName,
197	apkPath,
198	launchFlags,
199	packageName,
200	projectPath,
201	}: {
202	activityName: string;
203	apkPath?: string;
204	launchFlags?: string;
205	packageName: string;
206
207	projectPath?: string;
208	}) {
209	const devices = await getDevices();	1✔
210	// install and launch the app if 1 emulator instance is running
211	if (devices.length === 1) {	1!
212	log.debug(`${devices[0].split('\t')[0]} is running ...`);	×
213	await installAndLaunchApp({	×
214	activityName,
215	apkPath,
216	launchFlags,
217	packageName,
218	projectPath,
219	});
220	} else if (devices.length > 1) {	1!
221	throw new Error('More than one device/emulator is running !');	1✔
222	} else {
223	const avdImageName = await askUserToSelectAvdEmulator();	×
224	return runAndroidUsingAvdImage({	×
225	activityName,
226	apkPath,
227	avdImageName,
228	launchFlags,
229	packageName,
230	projectPath,
231	});
232	}
233	}
234
235	export async function askUserToSelectAvdEmulator(): Promise<string> {	24✔
236	const avdImageNames = await getAndroidAvds();	5✔
237	if (Array.isArray(avdImageNames) && avdImageNames.length === 0) {	5!
238	throw new Error(	×
239	`No Emulator or device found. Launch an emulator manually or connect a device.${ANDROID_DEVICE_INFO}`,
240	);
241	}
242	const deviceConfig = ernConfig.get(deviceConfigUtil.ANDROID_DEVICE_CONFIG);	5✔
243	// Check if user has set the usePreviousEmulator flag to true
244	if (avdImageNames && deviceConfig) {	5✔
245	if (deviceConfig.usePreviousDevice) {	4✔
246	// Get the name of previously used device
247	const deviceId = deviceConfig.deviceId;	2✔
248	// Check if avd image still exists
249	const avdIndex = avdImageNames.indexOf(deviceId);	2✔
250	if (avdIndex > -1) {	2✔
251	return `${avdImageNames[avdIndex]}`;	1✔
252	}
253	}
254	}
255
256	// if avd image is still not resolved
257	const { avdImageName } = await inquirer.prompt([	4✔
258	<inquirer.Question>{
259	choices: avdImageNames,
260	message: 'Choose Android device image',
261	name: 'avdImageName',
262	type: 'list',
263	},
264	]);
265
266	// Update the device Config
267	if (deviceConfig) {	4✔
268	deviceConfig.deviceId = avdImageName;	3✔
269	ernConfig.set(deviceConfigUtil.ANDROID_DEVICE_CONFIG, deviceConfig);	3✔
270	}
271	return `${avdImageName}`;	4✔
272	}
273
274	// Does the job of actually running the app
275	// It orchestrates a few tasks to actually get the job done
276	// Params :
277	// - projectPath : Absolute or relative path to the root of the Android projectPath
278	// - packageName : name of the package containing the application
279	// - avdImageName : name of the avd image to use (device image)
280	export async function runAndroidUsingAvdImage({	24✔
281	activityName,
282	apkPath,
283	launchFlags,
284	avdImageName,
285	packageName,
286	projectPath,
287	}: {
288	activityName: string;
289	apkPath?: string;
290	avdImageName: string;
291	launchFlags?: string;
292	packageName: string;
293	projectPath?: string;
294	}) {
295	// https://issuetracker.google.com/issues/37137213
296	spawnp(androidEmulatorPath(), ['-avd', avdImageName], { detached: true });	×
297	await kax	×
298	.task('Waiting for device to start')
299	.run(
300	Promise.race([waitForAndroidDevice(), failAfterTimeOut(3 * 60 * 1000)]),
301	);
302	await installAndLaunchApp({	×
303	activityName,
304	apkPath,
305	launchFlags,
306	packageName,
307	projectPath,
308	});
309	}
310
311	// Does the job of installing and running the app
312	// It orchestrates a few tasks to actually get the job done
313	// Params :
314	// - projectPath : Absolute or relative path to the root of the Android projectPath
315	// - packageName : name of the package containing the application
316	export async function installAndLaunchApp({	24✔
317	activityName,
318	apkPath,
319	launchFlags,
320	packageName,
321	projectPath,
322	}: {
323	activityName: string;
324	apkPath?: string;
325	launchFlags?: string;
326	packageName: string;
327	projectPath?: string;
328	}) {
329	if (projectPath) {	×
330	await kax	×
331	.task('Building and installing application')
332	.run(buildAndInstallApp(projectPath));
333	} else if (apkPath) {	×
334	await kax.task('Installing APK').run(installApk(apkPath));	×
335	}
336	await kax.task('Launching Android Application').run(Promise.resolve());	×
337	launchAndroidActivityDetached(packageName, activityName, { launchFlags });	×
338	}
339
340	// Utility method that basically completes whenever the android device is ready
341	// It check device readiness every 2 sec (poll way)
342	export async function waitForAndroidDevice() {	24✔
343	let androidBootAnimProp = await androidGetBootAnimProp();	×
344	while (!androidBootAnimProp.toString().startsWith('stopped')) {	×
345	await delay(2000);	×
346	androidBootAnimProp = await androidGetBootAnimProp();	×
347	}
348	}
349
350	// Utility method to know when the prop init.svc.bootanim is there
351	// which indicates somehow that device is ready to install APK and such
352	export async function androidGetBootAnimProp() {	24✔
353	return execp(	1✔
354	`${androidAdbPath()} wait-for-device shell getprop init.svc.bootanim`,
355	);
356	}
357
358	// Build & install application on the device
359	// params :
360	// - projectPath : Absolute or relative path to the root of the Android project
361	// containing the application
362	export async function buildAndInstallApp(projectPath: string) {	24✔
363	shell.pushd(projectPath);	×
364	try {	×
365	const gradlew = getGradleByPlatform();	×
366	return execp(`${gradlew} installDebug`);	×
367	} finally {
368	shell.popd();	×
369	}
370	}
371
372	export function getGradleByPlatform(): string {	24✔
373	return /^win/.test(process.platform) ? 'gradlew' : './gradlew';	3✔
374	}
375
376	// Utility method to launch a specific activity from a given package
377	// Params :
378	// - packageName : name of the package containing the application
379	// - activityName : name of the Activity to launch
380	export async function launchAndroidActivity(	24✔
381	packageName: string,
382	activityName: string,
383	) {
384	return execp(	×
385	`${androidAdbPath()} shell am start -n ${packageName}/.${activityName}`,
386	);
387	}
388
389	// Utility method to launch a specific activity from a given packager
390	// Will spawn the command (detached mode)
391	export function launchAndroidActivityDetached(	24✔
392	packageName: string,
393	activityName: string,
394	{ launchFlags = '' }: { launchFlags?: string } = {},	×
395	) {
396	spawnp(	×
397	androidAdbPath(),
398	[
399	'shell',
400	'am',
401	'start',
402	'-n',
403	`${packageName}/.${activityName}`,
404	launchFlags,
405	],
406	{ detached: true },
407	);
408	}
409
410	// Utility method to list all available android avd images (emulator images)
411	export async function getAndroidAvds() {	24✔
412	const stdout = await execp(`${androidEmulatorPath()} -list-avds`);	8✔
413	let avdArr: string[] = [];	8✔
414	if (stdout) {	8✔
415	avdArr = stdout.toString().trim().split(/\r?\n/);	7✔
416	}
417	return avdArr;	8✔
418	}
419
420	// Utility method to query what device instances are connected to the adb server
421	export async function getDevices(): Promise<string[]> {	24✔
422	const stdout = await execp(`${androidAdbPath()} devices`);	3✔
423	/*
424	stdout for running command $adb devices
425	List of devices attached
426	* daemon not running. starting it now at tcp:5037 *
427	* daemon started successfully *
428	*/
429	const stdOutArr = stdout.toString().trim().split(/\r?\n/);	3✔
430	// remove stdout 'List of devices attached' (position 0)
431	// and remove stdout related to daemon
432	return stdOutArr.filter((entry, i) => i > 0 && !entry.includes('* daemon'));	11✔
433	}
434
435	export async function installApk(pathToApk: string) {	24✔
436	return execp(`${androidAdbPath()} install -r ${pathToApk}`);	×
437	}
438
439	export function androidSdkRoot(): string \| undefined {	24✔
440	return process.env.ANDROID_SDK_ROOT ?? process.env.ANDROID_HOME;	12!
441	}
442
443	export function androidAdbPath(): string {	24✔
444	const sdkRoot = androidSdkRoot();	4✔
445	return sdkRoot ? `${sdkRoot}/platform-tools/adb` : 'adb';	4!
446	}
447
448	export function androidEmulatorPath(): string {	24✔
449	const sdkRoot = androidSdkRoot();	8✔
450	if (sdkRoot) {	8!
451	if (fs.existsSync(`${sdkRoot}/emulator/emulator`)) {	8!
UNCOV 452	return `${sdkRoot}/emulator/emulator`;	×
453	}
454	if (fs.existsSync(`${sdkRoot}/tools/emulator`)) {	8!
455	return `${sdkRoot}/tools/emulator`;	×
456	}
457	}
458	return 'emulator';	8✔
459	}
460
461	/**
462	* Returns the default Hermes engine (hermes-engine) package version used by a given React Native version.
463	* Only works for versions of RN >= 0.60.0 as hermes-engine package was introduced in this version.
464	*/
465	export function getDefaultHermesVersion(	24✔
466	reactNativeVersion: string,
467	): string \| never {
468	if (semver.gte(reactNativeVersion, '0.66.0')) {	10!
469	// https://github.com/facebook/react-native/blob/v0.66.0/package.json#L98
470	return '~0.9.0';	×
471	} else if (semver.gte(reactNativeVersion, '0.65.0')) {	10!
472	// https://github.com/facebook/react-native/blob/v0.65.0/package.json#L98
473	return '~0.8.1';	×
474	} else if (semver.gte(reactNativeVersion, '0.64.0')) {	10!
475	// https://github.com/facebook/react-native/blob/v0.64.0/package.json#L97
476	return '~0.7.0';	×
477	} else if (semver.gte(reactNativeVersion, '0.63.0')) {	10✔
478	// https://github.com/facebook/react-native/blob/v0.63.0/package.json#L98
479	return '~0.5.0';	2✔
480	} else if (semver.gte(reactNativeVersion, '0.62.0')) {	8✔
481	return '~0.4.0';	3✔
482	} else if (semver.gte(reactNativeVersion, '0.60.0')) {	5✔
483	return '^0.2.1';	4✔
484	} else {
485	throw new Error(	1✔
486	'This function can only be called for versions of React Native >= 0.60.0',
487	);
488	}
489	}
490
491	/**
492	* Returns the default JavaScriptCore engine version used
493	* by a given React Native version.
494	* Only works for versions of RN >= 0.60.0 as dynamic jsc-android
495	* package was introduced in this version.
496	*/
497	export function getDefaultJSCVersion(	24✔
498	reactNativeVersion: string,
499	): string \| never {
500	if (semver.gte(reactNativeVersion, '0.65.0')) {	×
501	return '^250230.2.1';	×
502	} else if (semver.gte(reactNativeVersion, '0.61.0')) {	×
503	return '^245459.0.0';	×
504	} else if (semver.gte(reactNativeVersion, '0.60.0')) {	×
505	return '245459.0.0';	×
506	} else {
507	throw new Error(	×
508	'This function can only be called for versions of React Native >= 0.60.0',
509	);
510	}
511	}

electrode-io / electrode-native / 7214

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous