@react-native-harness/platform-android 1.1.0 → 1.2.0

package/dist/__tests__/adb-id.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adb-id.test.d.ts.map

package/dist/__tests__/adb-id.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb-id.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/adb-id.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/adb-id.test.js

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getAdbId, isAdbIdEmulator } from '../adb-id.js';
+import * as adb from '../adb.js';
+describe('adb id resolution', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('identifies emulator adb ids', () => {
+        expect(isAdbIdEmulator('emulator-5554')).toBe(true);
+        expect(isAdbIdEmulator('device-serial-001')).toBe(false);
+    });
+    it('skips non-emulator ids when resolving an emulator device', async () => {
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([
+            'device-serial-001',
+            'emulator-5554',
+        ]);
+        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Test_AVD_API_35');
+        await expect(getAdbId({
+            type: 'emulator',
+            name: 'Test_AVD_API_35',
+        })).resolves.toBe('emulator-5554');
+    });
+    it('resolves matching physical device by manufacturer and model', async () => {
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([
+            'device-serial-001',
+            'emulator-5554',
+        ]);
+        vi.spyOn(adb, 'getDeviceInfo').mockImplementation(async (adbId) => {
+            const results = {
+                'device-serial-001': { manufacturer: 'Acme', model: 'Model A1' },
+                'emulator-5554': { manufacturer: 'Emulator', model: 'Emulator Model' },
+            };
+            return results[adbId] || null;
+        });
+        await expect(getAdbId({
+            type: 'physical',
+            manufacturer: 'acme',
+            model: 'model a1',
+        })).resolves.toBe('device-serial-001');
+    });
+});

package/dist/__tests__/adb.test.js

@@ -1,12 +1,17 @@
 import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { PassThrough } from 'node:stream';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { SubprocessError } from '@react-native-harness/tools';
-import { createAvd, deleteAvd, emulatorProcess, getAppUid, getLogcatTimestamp, getStartAppArgs, hasAvd, installApp, startEmulator, waitForBoot, waitForEmulatorDisconnect, } from '../adb.js';
+vi.unmock('../adb.js');
+import { createAvd, deleteAvd, emulatorProcess, getAppUid, getLogcatTimestamp, getStartAppArgs, hasAvd, installApp, startLogcat, startEmulator, uninstallApp, waitForBoot, waitForEmulatorDisconnect, } from '../adb.js';
 import * as tools from '@react-native-harness/tools';
 import * as environment from '../environment.js';
 import * as avdConfig from '../avd-config.js';
 const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+let sdkRoot;
 const createMockChildProcess = () => {
     const process = new EventEmitter();
     process.stdout = new PassThrough();
@@ -16,6 +21,14 @@ const createMockChildProcess = () => {
 };
 beforeEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    sdkRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'android-sdk-'));
+    fs.mkdirSync(path.join(sdkRoot, 'emulator'), { recursive: true });
+    fs.writeFileSync(path.join(sdkRoot, 'emulator', 'emulator'), '');
+    fs.mkdirSync(path.join(sdkRoot, 'platform-tools'), { recursive: true });
+    fs.writeFileSync(path.join(sdkRoot, 'platform-tools', 'adb'), '');
+    vi.stubEnv('ANDROID_HOME', sdkRoot);
+    vi.spyOn(environment, 'ensureAndroidEmulatorAvailable').mockResolvedValue(sdkRoot);
 });
 describe('getStartAppArgs', () => {
     it('maps supported extras to adb am start flags', () => {
@@ -81,8 +94,31 @@ describe('getStartAppArgs', () => {
             "+'%m-%d %H:%M:%S.000'",
         ]);
     });
+    it('starts logcat using the resolved adb binary path', async () => {
+        const subprocess = {};
+        const spawnSpy = vi.spyOn(tools, 'spawn').mockReturnValue(subprocess);
+        expect(startLogcat('emulator-5554', [
+            'logcat',
+            '-v',
+            'threadtime',
+            '-b',
+            'crash',
+        ])).toBe(subprocess);
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
+            '-s',
+            'emulator-5554',
+            'logcat',
+            '-v',
+            'threadtime',
+            '-b',
+            'crash',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+    });
     it('checks whether an AVD exists', async () => {
-        vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
+        vi.spyOn(tools, 'spawn').mockResolvedValue({
             stdout: 'Pixel_6_API_33\nPixel_8_API_35\n',
         });
         await expect(hasAvd('Pixel_8_API_35')).resolves.toBe(true);
@@ -101,6 +137,18 @@ describe('getStartAppArgs', () => {
             '/tmp/app.apk',
         ]);
     });
+    it('uninstalls the app via adb', async () => {
+        const spawnSpy = vi
+            .spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({});
+        await uninstallApp('emulator-5554', 'com.example.app');
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
+            '-s',
+            'emulator-5554',
+            'uninstall',
+            'com.example.app',
+        ]);
+    });
     it('creates an AVD and appends config overrides', async () => {
         vi.spyOn(avdConfig, 'readAvdConfig').mockResolvedValue({});
         const spawnSpy = vi
@@ -353,17 +401,24 @@ describe('getStartAppArgs', () => {
     });
     it('aborts while waiting for boot completion', async () => {
         vi.useFakeTimers();
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy
-            .mockResolvedValueOnce({
-            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
-        })
-            .mockResolvedValueOnce({
-            stdout: 'Pixel_8_API_35\n',
-        })
-            .mockResolvedValueOnce({
-            stdout: '0\n',
-        });
+        vi.spyOn(tools, 'spawn').mockImplementation((async (_file, args) => {
+            if (args?.[0] === 'devices') {
+                return {
+                    stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+                };
+            }
+            if (args?.includes('emu') && args?.includes('avd') && args?.includes('name')) {
+                return {
+                    stdout: 'Pixel_8_API_35\n',
+                };
+            }
+            if (args?.includes('getprop')) {
+                return {
+                    stdout: '0\n',
+                };
+            }
+            throw new Error(`Unexpected adb call: ${args?.join(' ')}`);
+        }));
         const controller = new AbortController();
         const waitPromise = waitForBoot('Pixel_8_API_35', controller.signal);
         await vi.advanceTimersByTimeAsync(1000);
@@ -414,4 +469,84 @@ describe('getStartAppArgs', () => {
         await expect(waitPromise).resolves.toBeUndefined();
         expect(spawnSpy).toHaveBeenCalledTimes(2);
     });
+    it('grants requested dangerous permissions to an app', async () => {
+        const { grantPermissions } = await import('../adb.js');
+        const spawnSpy = vi
+            .spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({
+            stdout: 'package:com.example.app\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: `requested permissions:\n  android.permission.CAMERA\n  android.permission.INTERNET\n  android.permission.ACCESS_FINE_LOCATION\ninstall permissions:\n`,
+        })
+            .mockResolvedValueOnce({
+            stdout: `Dangerous Permissions:\n  permission:android.permission.CAMERA\n  permission:android.permission.ACCESS_FINE_LOCATION\n`,
+        })
+            .mockResolvedValue({
+            stdout: '',
+        });
+        await grantPermissions('emulator-5554', 'com.example.app');
+        expect(spawnSpy).toHaveBeenCalledTimes(5);
+        expect(spawnSpy).toHaveBeenNthCalledWith(1, expect.any(String), [
+            '-s',
+            'emulator-5554',
+            'shell',
+            'pm',
+            'list',
+            'packages',
+            'com.example.app',
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(2, expect.any(String), [
+            '-s',
+            'emulator-5554',
+            'shell',
+            'dumpsys',
+            'package',
+            'com.example.app',
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(3, expect.any(String), [
+            '-s',
+            'emulator-5554',
+            'shell',
+            'pm',
+            'list',
+            'permissions',
+            '-g',
+            '-d',
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(4, expect.any(String), [
+            '-s',
+            'emulator-5554',
+            'shell',
+            'pm',
+            'grant',
+            'com.example.app',
+            'android.permission.CAMERA',
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(5, expect.any(String), [
+            '-s',
+            'emulator-5554',
+            'shell',
+            'pm',
+            'grant',
+            'com.example.app',
+            'android.permission.ACCESS_FINE_LOCATION',
+        ]);
+    });
+    it('does nothing when the app has no grantable dangerous permissions', async () => {
+        const { grantPermissions } = await import('../adb.js');
+        const spawnSpy = vi
+            .spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({
+            stdout: 'package:com.example.app\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: `requested permissions:\n  android.permission.INTERNET\ninstall permissions:\n`,
+        })
+            .mockResolvedValueOnce({
+            stdout: `Dangerous Permissions:\n  permission:android.permission.CAMERA\n`,
+        });
+        await grantPermissions('emulator-5554', 'com.example.app');
+        expect(spawnSpy).toHaveBeenCalledTimes(3);
+    });
 });

package/dist/__tests__/app-monitor.test.js

@@ -3,8 +3,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { tmpdir } from 'node:os';
 import { createAndroidAppMonitor, createAndroidLogEvent } from '../app-monitor.js';
-import * as tools from '@react-native-harness/tools';
 import { createCrashArtifactWriter } from '@react-native-harness/tools';
+import * as adb from '../adb.js';
 const createMockSubprocess = () => ({
     nodeChildProcess: Promise.resolve({
         kill: vi.fn(),
@@ -55,15 +55,12 @@ describe('createAndroidLogEvent', () => {
         });
     });
     it('starts logcat from the current device timestamp', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 11:35:08.000\n',
-                };
-            }
-            return createMockSubprocess();
-        }));
+        const getLogcatTimestampSpy = vi
+            .spyOn(adb, 'getLogcatTimestamp')
+            .mockResolvedValue('03-12 11:35:08.000');
+        const startLogcatSpy = vi
+            .spyOn(adb, 'startLogcat')
+            .mockReturnValue(createMockSubprocess());
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
@@ -71,9 +68,8 @@ describe('createAndroidLogEvent', () => {
         });
         await monitor.start();
         await monitor.stop();
-        expect(spawnSpy).toHaveBeenNthCalledWith(2, 'adb', [
-            '-s',
-            'emulator-5554',
+        expect(getLogcatTimestampSpy).toHaveBeenCalledWith('emulator-5554');
+        expect(startLogcatSpy).toHaveBeenCalledWith('emulator-5554', [
             'logcat',
             '-v',
             'threadtime',
@@ -82,34 +78,24 @@ describe('createAndroidLogEvent', () => {
             '--uid=10234',
             '-T',
             '03-12 11:35:08.000',
-        ], {
-            stdout: 'pipe',
-            stderr: 'pipe',
-        });
+        ]);
     });
     it('hydrates crash details with stack lines that arrive after the first crash event', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 10:44:40.000\n',
-                };
-            }
-            return createStreamingSubprocess([
-                { line: '--------- beginning of crash' },
-                {
-                    line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-                },
-                {
-                    line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                    delayMs: 25,
-                },
-                {
-                    line: '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
-                    delayMs: 25,
-                },
-            ]);
-        }));
+        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('03-12 10:44:40.000');
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            { line: '--------- beginning of crash' },
+            {
+                line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+            },
+            {
+                line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
+                delayMs: 25,
+            },
+            {
+                line: '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+                delayMs: 25,
+            },
+        ]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
@@ -130,24 +116,17 @@ describe('createAndroidLogEvent', () => {
         ]);
     });
     it('persists resolved Android crash blocks into .harness', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 10:44:40.000\n',
-                };
-            }
-            return createStreamingSubprocess([
-                { line: '--------- beginning of crash' },
-                {
-                    line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-                },
-                {
-                    line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                    delayMs: 20,
-                },
-            ]);
-        }));
+        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('03-12 10:44:40.000');
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            { line: '--------- beginning of crash' },
+            {
+                line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+            },
+            {
+                line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
+                delayMs: 20,
+            },
+        ]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
@@ -171,21 +150,13 @@ describe('createAndroidLogEvent', () => {
         expect(fs.readFileSync(details.artifactPath, 'utf8')).toContain('RuntimeException: boom');
     });
     it('can be started again after timestamp lookup fails', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
         const timestampError = new Error('date failed');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                if (spawnSpy.mock.calls.filter(([calledFile, calledArgs]) => calledFile === 'adb' &&
-                    Array.isArray(calledArgs) &&
-                    calledArgs.includes('date')).length === 1) {
-                    throw timestampError;
-                }
-                return {
-                    stdout: '03-12 11:35:08.000\n',
-                };
-            }
-            return createMockSubprocess();
-        }));
+        vi.spyOn(adb, 'getLogcatTimestamp')
+            .mockRejectedValueOnce(timestampError)
+            .mockResolvedValueOnce('03-12 11:35:08.000');
+        const startLogcatSpy = vi
+            .spyOn(adb, 'startLogcat')
+            .mockReturnValue(createMockSubprocess());
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
@@ -194,9 +165,15 @@ describe('createAndroidLogEvent', () => {
         await expect(monitor.start()).rejects.toThrow(timestampError);
         await expect(monitor.start()).resolves.toBeUndefined();
         await monitor.stop();
-        expect(spawnSpy.mock.calls.some(([file, args]) => file === 'adb' &&
-            Array.isArray(args) &&
-            args.includes('logcat') &&
-            args.includes('--uid=10234'))).toBe(true);
+        expect(startLogcatSpy).toHaveBeenCalledWith('emulator-5554', [
+            'logcat',
+            '-v',
+            'threadtime',
+            '-b',
+            'crash',
+            '--uid=10234',
+            '-T',
+            '03-12 11:35:08.000',
+        ]);
     });
 });

package/dist/__tests__/emulator-startup.test.js

@@ -7,6 +7,7 @@ describe('emulator startup modes', () => {
             '-no-snapshot-load',
             '-no-snapshot-save',
         ]));
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'default-boot')).not.toEqual(expect.arrayContaining(['-camera-back', 'none']));
     });
     it('builds clean snapshot generation args', () => {
         expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).toEqual(expect.arrayContaining(['@Pixel_8_API_35', '-no-snapshot-load']));

package/dist/__tests__/instance.test.js

@@ -1,8 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { DEFAULT_METRO_PORT, } from '@react-native-harness/config';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { getAndroidEmulatorPlatformInstance, getAndroidPhysicalDevicePlatformInstance, } from '../instance.js';
 import * as adb from '../adb.js';
 import * as avdConfig from '../avd-config.js';
@@ -19,9 +16,10 @@ const init = {
     signal: new AbortController().signal,
 };
 describe('Android platform instance', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
         vi.restoreAllMocks();
         vi.unstubAllEnvs();
+        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorAvailable').mockResolvedValue('/tmp/android-sdk');
     });
     it('reuses a running emulator and does not shut it down on dispose', async () => {
         const ensureAndroidEmulatorEnvironment = vi
@@ -137,6 +135,7 @@ describe('Android platform instance', () => {
     });
     it('reuses a compatible cached AVD snapshot when caching is enabled', async () => {
         vi.stubEnv('HARNESS_AVD_CACHING', 'true');
+        vi.spyOn(await import('../environment.js'), 'getHostAndroidSystemImageArch').mockReturnValue('arm64-v8a');
         vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
         vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
         vi.spyOn(adb, 'hasAvd').mockResolvedValue(true);
@@ -261,38 +260,6 @@ describe('Android platform instance', () => {
         expect(waitForEmulatorDisconnect).toHaveBeenCalledWith('emulator-5554', init.signal);
         expect(startEmulator).toHaveBeenNthCalledWith(2, 'Pixel_8_API_35', 'snapshot-reuse');
     });
-    it('installs the app from HARNESS_APP_PATH when missing', async () => {
-        const appPath = path.join(os.tmpdir(), 'HarnessPlayground.apk');
-        fs.writeFileSync(appPath, 'apk');
-        vi.stubEnv('HARNESS_APP_PATH', appPath);
-        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
-        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
-        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
-        vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
-        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(false);
-        const installApp = vi.spyOn(adb, 'installApp').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
-        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
-        await expect(getAndroidEmulatorPlatformInstance({
-            name: 'android',
-            device: {
-                type: 'emulator',
-                name: 'Pixel_8_API_35',
-                avd: {
-                    apiLevel: 35,
-                    profile: 'pixel_8',
-                    diskSize: '1G',
-                    heapSize: '1G',
-                },
-            },
-            bundleId: 'com.harnessplayground',
-            activityName: '.MainActivity',
-        }, harnessConfig, init)).resolves.toBeDefined();
-        expect(installApp).toHaveBeenCalledWith('emulator-5554', appPath);
-        fs.rmSync(appPath, { force: true });
-    });
     it('throws a HarnessAppPathError when HARNESS_APP_PATH is missing', async () => {
         vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
         vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -420,4 +387,98 @@ describe('Android platform instance', () => {
         expect(appMonitor.addListener(listener)).toBeUndefined();
         expect(appMonitor.removeListener(listener)).toBeUndefined();
     });
+    it('grants permissions when permissions are enabled for emulator', async () => {
+        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+        vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
+        const grantPermissions = vi
+            .spyOn(adb, 'grantPermissions')
+            .mockResolvedValue(undefined);
+        const harnessConfigWithPermissions = {
+            ...harnessConfig,
+            permissions: true,
+        };
+        await getAndroidEmulatorPlatformInstance({
+            name: 'android',
+            device: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '1G',
+                },
+            },
+            bundleId: 'com.harnessplayground',
+            activityName: '.MainActivity',
+        }, harnessConfigWithPermissions, init);
+        expect(grantPermissions).toHaveBeenCalledWith('emulator-5554', 'com.harnessplayground');
+    });
+    it('does not grant permissions when permissions are disabled for emulator', async () => {
+        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+        vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
+        const grantPermissions = vi
+            .spyOn(adb, 'grantPermissions')
+            .mockResolvedValue(undefined);
+        await getAndroidEmulatorPlatformInstance({
+            name: 'android',
+            device: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '1G',
+                },
+            },
+            bundleId: 'com.harnessplayground',
+            activityName: '.MainActivity',
+        }, harnessConfig, init);
+        expect(grantPermissions).not.toHaveBeenCalled();
+    });
+    it('grants permissions when permissions are enabled for physical device', async () => {
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['012345']);
+        vi.spyOn(adb, 'getDeviceInfo').mockResolvedValue({
+            manufacturer: 'motorola',
+            model: 'moto g72',
+        });
+        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
+        const grantPermissions = vi
+            .spyOn(adb, 'grantPermissions')
+            .mockResolvedValue(undefined);
+        const harnessConfigWithPermissions = {
+            ...harnessConfig,
+            permissions: true,
+        };
+        await getAndroidPhysicalDevicePlatformInstance({
+            name: 'android-device',
+            device: {
+                type: 'physical',
+                manufacturer: 'motorola',
+                model: 'moto g72',
+            },
+            bundleId: 'com.harnessplayground',
+            activityName: '.MainActivity',
+        }, harnessConfigWithPermissions);
+        expect(grantPermissions).toHaveBeenCalledWith('012345', 'com.harnessplayground');
+    });
 });

package/dist/adb-errors.d.ts

@@ -0,0 +1,16 @@
+export declare class AdbError extends Error {
+    constructor(message: string);
+}
+export declare class AdbDeviceNotFoundError extends AdbError {
+    constructor(adbId: string);
+}
+export declare class AdbAppNotInstalledError extends AdbError {
+    constructor(bundleId: string, adbId: string);
+}
+export declare class AdbPermissionGrantError extends AdbError {
+    constructor(bundleId: string, permissions: string[], adbId: string);
+}
+export declare class AdbBinaryNotFoundError extends AdbError {
+    constructor();
+}
+//# sourceMappingURL=adb-errors.d.ts.map

package/dist/adb-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb-errors.d.ts","sourceRoot":"","sources":["../src/adb-errors.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAS,SAAQ,KAAK;gBACrB,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,sBAAuB,SAAQ,QAAQ;gBACtC,KAAK,EAAE,MAAM;CAO1B;AAED,qBAAa,uBAAwB,SAAQ,QAAQ;gBACvC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAO5C;AAED,qBAAa,uBAAwB,SAAQ,QAAQ;gBACvC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM;CAQnE;AAED,qBAAa,sBAAuB,SAAQ,QAAQ;;CAQnD"}