refactor: handling gradle tasks, mode, args and show build output file (#36)

* refactor: handling gradle tasks, mode, args and show build output file

* update output

* fix tests

Author: thymikee

packages/cli/src/lib/commands/fingerprint.ts

@@ -34,5 +34,5 @@ export async function nativeFingerprintCommand(
     logger.debug(`Duration: ${(duration / 1000).toFixed(1)}s`);
   }
   loader.stop(`Fingerprint calculated: ${fingerprint.hash}`);
-  outro('Success.');
+  outro('Success 🎉.');
 }

packages/plugin-platform-android/package.json

@@ -12,6 +12,7 @@
     "@react-native-community/cli-config-android": "^15.1.2",
     "chalk": "^5.3.0",
     "nano-spawn": "^0.2.0",
+    "picocolors": "^1.1.1",
     "tslib": "^2.3.0"
   },
   "devDependencies": {

packages/plugin-platform-android/src/lib/commands/buildAndroid/__tests__/buildAndroid.test.ts

@@ -1,10 +1,15 @@
+import fs, { PathLike } from 'node:fs';
 import { vi, test, Mock, MockedFunction } from 'vitest';
 import { AndroidProjectConfig } from '@react-native-community/cli-types';
 import { logger } from '@callstack/rnef-tools';
 import spawn from 'nano-spawn';
 import { select } from '@clack/prompts';
 import { buildAndroid, type BuildFlags } from '../buildAndroid.js';
+import color from 'picocolors';
 
+const actualFs = await vi.importMock('node:fs');
+
+vi.mock('node:fs');
 vi.mock('nano-spawn', () => {
   return {
     default: vi.fn(),
@@ -71,15 +76,45 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
-test('buildAndroid runs gradle build with correct configuration for debug', async () => {
-  (spawn as Mock).mockResolvedValueOnce({ output: 'output' });
+function mockCallAdbGetCpu(file: string, args: string[]) {
+  return (
+    file === '/mock/android/home/platform-tools/adb' &&
+    args?.[0] === 'shell' &&
+    args?.[1] === 'getprop' &&
+    args?.[2] === 'ro.product.cpu.abi'
+  );
+}
+
+function spawnMockImplementation(file: string, args: string[]) {
+  if (mockCallAdbGetCpu(file, args)) {
+    return { output: 'arm64-v8a' };
+  }
+  return { output: '...' };
+}
+
+test('buildAndroid runs gradle build with correct configuration for debug and outputs build path', async () => {
+  (spawn as Mock).mockImplementation((file, args) =>
+    spawnMockImplementation(file, args)
+  );
+  vi.mocked(fs.existsSync).mockImplementation((file: PathLike) => {
+    if (file === '/android/app/build/outputs/bundle/debug/app-debug.aab') {
+      return true;
+    }
+    return (actualFs as typeof fs).existsSync(file);
+  });
+
   await buildAndroid(androidProject, args);
 
   expect(vi.mocked(spawn)).toBeCalledWith(
     './gradlew',
     ['app:bundleDebug', '-x', 'lint'],
     { stdio: 'inherit', cwd: '/android' }
   );
+  expect(mocks.stopMock).toBeCalledWith(
+    `Build output: ${color.cyan(
+      '/android/app/build/outputs/bundle/debug/app-debug.aab'
+    )}`
+  );
 });
 
 test('buildAndroid fails gracefully when gradle errors', async () => {
@@ -106,11 +141,20 @@ test('buildAndroid runs selected "bundleRelease" task in interactive mode', asyn
     if (file === './gradlew' && args[0] === 'tasks') {
       return { output: gradleTaskOutput };
     }
+    if (mockCallAdbGetCpu(file, args)) {
+      return { output: 'arm64-v8a' };
+    }
     return { output: 'output' };
   });
   (select as MockedFunction<typeof select>).mockResolvedValueOnce(
     Promise.resolve('bundleRelease')
   );
+  vi.mocked(fs.existsSync).mockImplementation((file: PathLike) => {
+    if (file === '/android/app/build/outputs/bundle/release/app-release.aab') {
+      return true;
+    }
+    return (actualFs as typeof fs).existsSync(file);
+  });
 
   await buildAndroid(androidProject, { ...args, interactive: true });
 
@@ -130,5 +174,5 @@ test('buildAndroid runs selected "bundleRelease" task in interactive mode', asyn
     'Searching for available Gradle tasks...'
   );
   expect(mocks.stopMock).toBeCalledWith('Found 2 Gradle tasks.');
-  expect(mocks.outroMock).toBeCalledWith('Success.');
+  expect(mocks.outroMock).toBeCalledWith('Success 🎉.');
 });

packages/plugin-platform-android/src/lib/commands/buildAndroid/buildAndroid.ts

@@ -1,11 +1,14 @@
 import { AndroidProjectConfig } from '@react-native-community/cli-types';
 import { runGradle } from '../runGradle.js';
 import { promptForTaskSelection } from '../listAndroidTasks.js';
-import { intro, outro } from '@clack/prompts';
+import { findOutputFile } from '../runAndroid/tryInstallAppOnDevice.js';
+import { outro, spinner } from '@clack/prompts';
 import { logger } from '@callstack/rnef-tools';
+import color from 'picocolors';
+import { toPascalCase } from '../toPascalCase.js';
 
 export interface BuildFlags {
-  mode?: string;
+  mode: string;
   activeArchOnly?: boolean;
   tasks?: Array<string>;
   extraParams?: Array<string>;
@@ -17,14 +20,21 @@ export async function buildAndroid(
   args: BuildFlags
 ) {
   normalizeArgs(args);
-  intro('Building Android app.');
 
-  const selectedTask = args.interactive
-    ? await promptForTaskSelection('bundle', androidProject.sourceDir)
-    : undefined;
+  const tasks = args.interactive
+    ? [await promptForTaskSelection('bundle', androidProject.sourceDir)]
+    : [...(args.tasks ?? []), `bundle${toPascalCase(args.mode)}`];
 
-  await runGradle({ taskType: 'bundle', androidProject, args, selectedTask });
-  outro('Success.');
+  await runGradle({ tasks, androidProject, args });
+
+  const outputFilePath = await findOutputFile(androidProject, tasks);
+
+  if (outputFilePath) {
+    const loader = spinner();
+    loader.start('');
+    loader.stop(`Build output: ${color.cyan(outputFilePath)}`);
+  }
+  outro('Success 🎉.');
 }
 
 function normalizeArgs(args: BuildFlags) {
@@ -33,6 +43,9 @@ function normalizeArgs(args: BuildFlags) {
       'Both "--tasks" and "--mode" parameters were passed. Using "--tasks" for building the app.'
     );
   }
+  if (!args.mode) {
+    args.mode = 'debug';
+  }
 }
 
 export const options = [

packages/plugin-platform-android/src/lib/commands/runAndroid/__tests__/runAndroid.test.ts

@@ -292,7 +292,7 @@ function spawnMockImplementation(
   return { output: '...' };
 }
 
-test.each([['release'], [undefined], ['staging']])(
+test.each([['release'], ['debug'], ['staging']])(
   'runAndroid runs gradle build with correct configuration for --mode %s and launches on emulator-5552',
   async (mode) => {
     (spawn as Mock).mockImplementation((file, args) =>
@@ -301,7 +301,7 @@ test.each([['release'], [undefined], ['staging']])(
     const logErrorSpy = vi.spyOn(logger, 'error');
     await runAndroid({ ...androidProject }, { ...args, mode }, '/');
 
-    expect(mocks.outroMock).toBeCalledWith('Success.');
+    expect(mocks.outroMock).toBeCalledWith('Success 🎉.');
     expect(logErrorSpy).not.toBeCalled();
 
     // Runs installDebug with only active architecture arm64-v8a
@@ -349,7 +349,7 @@ test('runAndroid runs gradle build with custom --appId, --appIdSuffix and --main
     '/'
   );
 
-  expect(mocks.outroMock).toBeCalledWith('Success.');
+  expect(mocks.outroMock).toBeCalledWith('Success 🎉.');
   expect(logErrorSpy).not.toBeCalled();
 
   // launches com.custom.suffix app with OtherActivity on emulator-5552
@@ -375,7 +375,7 @@ test('runAndroid fails to launch an app on not-connected device when specified w
       '/'
     );
   } catch {
-    expect(mocks.outroMock).not.toBeCalledWith('Success.');
+    expect(mocks.outroMock).not.toBeCalledWith('Success 🎉.');
     expect(logErrorSpy).toBeCalledWith(
       'Device "emulator-5554" not found. Please run it first or use a different one.'
     );
@@ -385,8 +385,8 @@ test('runAndroid fails to launch an app on not-connected device when specified w
 test.each([
   ['release', true],
   ['release', false],
-  [undefined, true],
-  [undefined, false],
+  ['debug', true],
+  ['debug', false],
 ])(
   `runAndroid launches an app on a selected device emulator-5554 when connected in --mode %s and --interactive %b`,
   async (mode, interactive) => {

packages/plugin-platform-android/src/lib/commands/runAndroid/__tests__/runOnAllDevices.test.ts

@@ -70,17 +70,17 @@ describe('--appFolder', () => {
 
   it('uses task "install[Variant]" as default task', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, mode: 'debug' },
+      tasks: ['installDebug'],
+      args: { ...args },
       androidProject,
     });
     expect((spawn as Mock).mock.calls[0][1]).toContain('app:installDebug');
   });
 
   it('uses appName and default variant', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, mode: 'debug' },
+      tasks: ['installDebug'],
+      args: { ...args },
       androidProject: { ...androidProject, appName: 'someApp' },
     });
 
@@ -89,8 +89,8 @@ describe('--appFolder', () => {
 
   it('uses appName and custom variant', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, mode: 'release' },
+      tasks: ['installRelease'],
+      args: { ...args },
       androidProject: { ...androidProject, appName: 'anotherApp' },
     });
 
@@ -101,8 +101,8 @@ describe('--appFolder', () => {
 
   it('uses only task argument', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, tasks: ['someTask'] },
+      tasks: ['installDebug', 'someTask'],
+      args: { ...args },
       androidProject,
     });
 
@@ -111,8 +111,8 @@ describe('--appFolder', () => {
 
   it('uses appName and custom task argument', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, tasks: ['someTask'] },
+      tasks: ['someTask', 'installDebug'],
+      args: { ...args },
       androidProject: { ...androidProject, appName: 'anotherApp' },
     });
 
@@ -121,8 +121,8 @@ describe('--appFolder', () => {
 
   it('uses multiple tasks', async () => {
     await runGradle({
-      taskType: 'install',
-      args: { ...args, tasks: ['clean', 'someTask'] },
+      tasks: ['clean', 'someTask'],
+      args: { ...args },
       androidProject,
     });
 

packages/plugin-platform-android/src/lib/commands/runAndroid/runAndroid.ts

@@ -14,7 +14,7 @@ import path from 'path';
 import { BuildFlags, options } from '../buildAndroid/buildAndroid.js';
 import { promptForTaskSelection } from '../listAndroidTasks.js';
 import { runGradle } from '../runGradle.js';
-import { intro, outro, select } from '@clack/prompts';
+import { outro, select } from '@clack/prompts';
 import chalk from 'chalk';
 
 export interface Flags extends BuildFlags {
@@ -37,52 +37,39 @@ export async function runAndroid(
   args: Flags,
   projectRoot: string
 ) {
-  intro('Building and running Android app.');
   normalizeArgs(args, projectRoot);
 
   const { deviceId } = args.interactive
     ? await selectAndLaunchDevice()
     : { deviceId: args.device };
 
-  const selectedTask = args.interactive
-    ? await promptForTaskSelection(
-        deviceId ? 'assemble' : 'install',
-        androidProject.sourceDir
-      )
-    : undefined;
+  const mainTaskType = deviceId ? 'assemble' : 'install';
+  const tasks = args.interactive
+    ? [await promptForTaskSelection(mainTaskType, androidProject.sourceDir)]
+    : [...(args.tasks ?? []), `${mainTaskType}${toPascalCase(args.mode)}`];
 
   if (deviceId) {
-    await runGradle({
-      taskType: 'assemble',
-      androidProject,
-      args,
-      selectedTask,
-    });
+    await runGradle({ tasks, androidProject, args });
     if (!(await getDevices()).find((d) => d === deviceId)) {
       logger.error(
         `Device "${deviceId}" not found. Please run it first or use a different one.`
       );
       process.exit(1);
     }
-    await tryInstallAppOnDevice(deviceId, androidProject, args, selectedTask);
+    await tryInstallAppOnDevice(deviceId, androidProject, args, tasks);
     await tryLaunchAppOnDevice(deviceId, androidProject, args);
   } else {
     if ((await getDevices()).length === 0) {
       await tryLaunchEmulator();
     }
 
-    await runGradle({
-      taskType: 'install',
-      androidProject,
-      args,
-      selectedTask,
-    });
+    await runGradle({ tasks, androidProject, args });
 
     for (const device of await getDevices()) {
       await tryLaunchAppOnDevice(device, androidProject, args);
     }
   }
-  outro('Success.');
+  outro('Success 🎉.');
 }
 
 async function selectAndLaunchDevice() {
@@ -113,6 +100,10 @@ function normalizeArgs(args: Flags, projectRoot: string) {
     );
   }
 
+  if (!args.mode) {
+    args.mode = 'debug';
+  }
+
   // turn on activeArchOnly for debug to speed up local builds
   if (args.mode !== 'release' && args.activeArchOnly === undefined) {
     args.activeArchOnly = true;