@react-native-harness/platform-android 1.4.0 → 1.5.0

package/dist/__tests__/shared-prefs.test.js

@@ -1,87 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import * as tools from '@react-native-harness/tools';
-import { applyHarnessDebugHttpHost, clearHarnessDebugHttpHost, } from '../shared-prefs.js';
-const bundleId = 'com.example.app';
-const adbId = 'emulator-5554';
-const getWrittenContent = (calls) => {
-    const writeCall = calls.find(([, , options]) => {
-        if (!options || typeof options !== 'object' || !('stdin' in options)) {
-            return false;
-        }
-        return Boolean(options.stdin);
-    });
-    const options = writeCall?.[2];
-    if (!options || typeof options !== 'object' || !('stdin' in options)) {
-        throw new Error('Expected write call options.');
-    }
-    const content = options.stdin;
-    if (!content ||
-        typeof content !== 'object' ||
-        !('string' in content) ||
-        typeof content.string !== 'string') {
-        throw new Error('Expected write call with string stdin.');
-    }
-    return content.string;
-};
-const getWrittenContents = (calls) => calls
-    .filter(([, , options]) => {
-    if (!options || typeof options !== 'object' || !('stdin' in options)) {
-        return false;
-    }
-    return Boolean(options.stdin);
-})
-    .map((call) => getWrittenContent([call]));
-describe('Android shared preferences Metro host override', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('handles empty self-closing map files', async () => {
-        const spawnSpy = vi
-            .spyOn(tools, 'spawn')
-            .mockResolvedValueOnce({
-            stdout: '<?xml version="1.0" encoding="utf-8"?>\n<map />\n',
-        })
-            .mockResolvedValueOnce({});
-        await applyHarnessDebugHttpHost(adbId, bundleId, 'localhost:9090');
-        expect(getWrittenContent(spawnSpy.mock.calls)).toContain('<map>');
-        expect(getWrittenContent(spawnSpy.mock.calls)).toContain('</map>');
-        expect(getWrittenContent(spawnSpy.mock.calls)).toContain('<string name="debug_http_host">localhost:9090</string>');
-    });
-    it('restores the previous debug host on cleanup', async () => {
-        const spawnSpy = vi
-            .spyOn(tools, 'spawn')
-            .mockResolvedValueOnce({
-            stdout: [
-                '<?xml version="1.0" encoding="utf-8"?>',
-                '<map>',
-                '  <string name="debug_http_host">10.0.2.2:8081</string>',
-                '</map>',
-            ].join('\n'),
-        })
-            .mockResolvedValueOnce({})
-            .mockResolvedValueOnce({
-            stdout: [
-                '<?xml version="1.0" encoding="utf-8"?>',
-                '<map>',
-                '  <string name="debug_http_host">10.0.2.2:8081</string>',
-                '  <!-- react-native-harness:debug_http_host:start -->',
-                '  <string name="debug_http_host">localhost:9090</string>',
-                '  <!-- react-native-harness:debug_http_host:end -->',
-                '</map>',
-            ].join('\n'),
-        })
-            .mockResolvedValueOnce({});
-        await applyHarnessDebugHttpHost(adbId, bundleId, 'localhost:9090');
-        await clearHarnessDebugHttpHost(adbId, bundleId);
-        const writes = getWrittenContents(spawnSpy.mock.calls);
-        const firstWrite = writes[0];
-        const secondWrite = writes[1];
-        expect(firstWrite).toEqual(expect.stringContaining('<string name="harness_debug_http_host_backup">10.0.2.2:8081</string>'));
-        expect(firstWrite).toEqual(expect.stringContaining('<string name="debug_http_host">localhost:9090</string>'));
-        expect(firstWrite).toEqual(expect.not.stringContaining('<string name="debug_http_host">10.0.2.2:8081</string>'));
-        expect(secondWrite).toEqual(expect.stringContaining('<string name="debug_http_host">10.0.2.2:8081</string>'));
-        expect(secondWrite).toEqual(expect.not.stringContaining('<string name="harness_debug_http_host_backup">10.0.2.2:8081</string>'));
-        expect(secondWrite).toEqual(expect.not.stringContaining('<!-- react-native-harness:debug_http_host:start -->'));
-        expect(secondWrite).toEqual(expect.not.stringContaining('<string name="debug_http_host">localhost:9090</string>'));
-    });
-});

package/dist/__tests__/targets.test.d.ts

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

package/dist/__tests__/targets.test.d.ts.map

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

package/dist/__tests__/targets.test.js

@@ -1,49 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRunTargets } from '../targets.js';
-import * as adb from '../adb.js';
-import * as environment from '../environment.js';
-describe('Android target discovery', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        vi.unstubAllEnvs();
-    });
-    it('installs adb and emulator only for discovery', async () => {
-        const ensureAndroidAdbAvailable = vi
-            .spyOn(environment, 'ensureAndroidAdbAvailable')
-            .mockResolvedValue('/tmp/android-sdk');
-        const ensureAndroidEmulatorAvailable = vi
-            .spyOn(environment, 'ensureAndroidEmulatorAvailable')
-            .mockResolvedValue('/tmp/android-sdk');
-        vi.spyOn(adb, 'getAvds').mockResolvedValue(['Pixel_8_API_35']);
-        vi.spyOn(adb, 'getConnectedDevices').mockResolvedValue([
-            {
-                id: 'device-1',
-                manufacturer: 'Google',
-                model: 'Pixel 8',
-            },
-        ]);
-        await expect(getRunTargets()).resolves.toEqual([
-            {
-                type: 'emulator',
-                name: 'Pixel_8_API_35',
-                platform: 'android',
-                description: 'Android emulator',
-                device: {
-                    name: 'Pixel_8_API_35',
-                },
-            },
-            {
-                type: 'physical',
-                name: 'Google Pixel 8',
-                platform: 'android',
-                description: 'Physical device (device-1)',
-                device: {
-                    manufacturer: 'Google',
-                    model: 'Pixel 8',
-                },
-            },
-        ]);
-        expect(ensureAndroidAdbAvailable).toHaveBeenCalledTimes(1);
-        expect(ensureAndroidEmulatorAvailable).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/app-monitor.d.ts

@@ -1,13 +0,0 @@
-import { type AppMonitor, type AppCrashDetails, type CrashArtifactWriter, type CrashDetailsLookupOptions, type AppMonitorEvent } from '@react-native-harness/platforms';
-declare const createAndroidLogEvent: (line: string, bundleId: string) => AppMonitorEvent | null;
-export declare const createAndroidAppMonitor: ({ adbId, bundleId, appUid, crashArtifactWriter, }: {
-    adbId: string;
-    bundleId: string;
-    appUid: number;
-    crashArtifactWriter?: CrashArtifactWriter;
-}) => AndroidAppMonitor;
-export { createAndroidLogEvent };
-export type AndroidAppMonitor = AppMonitor & {
-    getCrashDetails: (options: CrashDetailsLookupOptions) => Promise<AppCrashDetails | null>;
-};
-//# sourceMappingURL=app-monitor.d.ts.map

package/dist/app-monitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-monitor.d.ts","sourceRoot":"","sources":["../src/app-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AA+SzC,QAAA,MAAM,qBAAqB,GACzB,MAAM,MAAM,EACZ,UAAU,MAAM,KACf,eAAe,GAAG,IAwEpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,mDAKrC;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,KAAG,iBA4KH,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAC3C,eAAe,EAAE,CACf,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;CACtC,CAAC"}

package/dist/app-monitor.js

@@ -1,376 +0,0 @@
-import { escapeRegExp, getEmitter, logger, SubprocessError, } from '@react-native-harness/tools';
-import * as adb from './adb.js';
-import { androidCrashParser } from './crash-parser.js';
-const androidAppMonitorLogger = logger.child('android-app-monitor');
-const getLogcatArgs = (uid, fromTime) => [
-    'logcat',
-    '-v',
-    'threadtime',
-    '-b',
-    'crash',
-    `--uid=${uid}`,
-    '-T',
-    fromTime,
-];
-const MAX_RECENT_LOG_LINES = 200;
-const MAX_RECENT_CRASH_ARTIFACTS = 10;
-const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
-const startProcPattern = (bundleId) => new RegExp(`Start proc (\\d+):${escapeRegExp(bundleId)}(?:/|\\s)`);
-const processPattern = (bundleId) => new RegExp(`Process:\\s*${escapeRegExp(bundleId)},\\s*PID:\\s*(\\d+)`);
-const nativeCrashPattern = (bundleId) => new RegExp(`>>>\\s*${escapeRegExp(bundleId)}\\s*<<<`);
-const processDiedPattern = (bundleId) => new RegExp(`Process\\s+${escapeRegExp(bundleId)}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`, 'i');
-const getSignal = (line) => {
-    const namedSignalMatch = line.match(/\b(SIG[A-Z0-9]+)\b/);
-    if (namedSignalMatch) {
-        return namedSignalMatch[1];
-    }
-    const signalNumberMatch = line.match(/signal\s+(\d+)/i);
-    if (signalNumberMatch) {
-        return `signal ${signalNumberMatch[1]}`;
-    }
-    return undefined;
-};
-const getAndroidLogLineCrashDetails = ({ line, bundleId, pid, }) => {
-    const fatalExceptionMatch = line.match(/FATAL EXCEPTION:\s*(.+)$/i);
-    const processMatch = line.match(processPattern(bundleId));
-    return {
-        source: 'logs',
-        summary: line.trim(),
-        signal: getSignal(line),
-        exceptionType: fatalExceptionMatch?.[1]?.trim(),
-        processName: processMatch
-            ? bundleId
-            : line.includes(bundleId)
-                ? bundleId
-                : undefined,
-        pid: pid ?? (processMatch ? Number(processMatch[1]) : undefined),
-        rawLines: [line],
-    };
-};
-const CRASH_BLOCK_HEADER = '--------- beginning of crash';
-const getLatestCrashBlock = (recentLogLines) => {
-    const lines = recentLogLines.map(({ line }) => line);
-    let latestCrashHeaderIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (/FATAL EXCEPTION:|Process:\s+.+,\s+PID:/i.test(lines[index])) {
-            latestCrashHeaderIndex = index;
-            break;
-        }
-    }
-    const blockStartIndex = Math.max(lines.lastIndexOf(CRASH_BLOCK_HEADER), latestCrashHeaderIndex);
-    if (blockStartIndex === -1) {
-        return lines;
-    }
-    return lines.slice(blockStartIndex);
-};
-const getCrashBlockForArtifact = ({ artifact, recentLogLines, }) => {
-    const targetIndex = recentLogLines.findIndex(({ line, occurredAt }) => line === artifact.triggerLine &&
-        (artifact.triggerOccurredAt === undefined ||
-            occurredAt === artifact.triggerOccurredAt));
-    if (targetIndex === -1) {
-        return artifact.rawLines ?? [];
-    }
-    let blockStartIndex = targetIndex;
-    for (let index = targetIndex; index >= 0; index -= 1) {
-        const { line } = recentLogLines[index];
-        if (line === CRASH_BLOCK_HEADER) {
-            blockStartIndex = index;
-            break;
-        }
-    }
-    let blockEndIndex = recentLogLines.length;
-    for (let index = targetIndex + 1; index < recentLogLines.length; index += 1) {
-        if (recentLogLines[index].line === CRASH_BLOCK_HEADER) {
-            blockEndIndex = index;
-            break;
-        }
-    }
-    return recentLogLines
-        .slice(blockStartIndex, blockEndIndex)
-        .map(({ line }) => line);
-};
-const hydrateCrashArtifact = ({ artifact, recentLogLines, }) => {
-    const rawLines = getCrashBlockForArtifact({ artifact, recentLogLines });
-    if (rawLines.length === 0) {
-        return artifact;
-    }
-    const parsedDetails = androidCrashParser.parse({
-        contents: rawLines.join('\n'),
-        bundleId: artifact.processName ?? '',
-        pid: artifact.pid,
-    });
-    return {
-        ...artifact,
-        ...parsedDetails,
-        artifactType: artifact.artifactType,
-        artifactPath: artifact.artifactPath,
-        rawLines,
-    };
-};
-const createCrashArtifact = ({ details, recentLogLines, }) => {
-    const occurredAt = Date.now();
-    const rawLines = getLatestCrashBlock(recentLogLines);
-    const triggerOccurredAt = [...recentLogLines]
-        .reverse()
-        .find(({ line }) => line === details.summary)?.occurredAt;
-    const contents = rawLines.length > 0
-        ? rawLines.join('\n')
-        : (details.rawLines ?? []).join('\n');
-    const parsedDetails = details.processName !== undefined
-        ? androidCrashParser.parse({
-            contents,
-            bundleId: details.processName,
-            pid: details.pid,
-        })
-        : details;
-    return {
-        ...parsedDetails,
-        occurredAt,
-        triggerLine: details.summary ?? '',
-        triggerOccurredAt,
-        artifactType: 'logcat',
-        rawLines: rawLines.length > 0
-            ? rawLines
-            : parsedDetails.rawLines ?? details.rawLines,
-    };
-};
-const persistCrashArtifact = ({ details, crashArtifactWriter, }) => {
-    if (!crashArtifactWriter || details.artifactType !== 'logcat') {
-        return details;
-    }
-    const artifactBody = details.rawLines?.join('\n');
-    if (!artifactBody) {
-        return details;
-    }
-    return {
-        ...details,
-        artifactPath: crashArtifactWriter.persistArtifact({
-            artifactKind: details.artifactType,
-            source: {
-                kind: 'text',
-                fileName: 'logcat.txt',
-                text: `${artifactBody}\n`,
-            },
-        }),
-    };
-};
-const getLatestCrashArtifact = ({ crashArtifacts, recentLogLines, processName, pid, occurredAt, }) => {
-    const matchingByPid = pid
-        ? crashArtifacts.filter((artifact) => artifact.pid === pid)
-        : [];
-    const matchingByProcess = processName
-        ? crashArtifacts.filter((artifact) => artifact.processName === processName)
-        : [];
-    const candidates = matchingByPid.length > 0
-        ? matchingByPid
-        : matchingByProcess.length > 0
-            ? matchingByProcess
-            : crashArtifacts;
-    const sortedCandidates = [...candidates].sort((left, right) => Math.abs(left.occurredAt - occurredAt) -
-        Math.abs(right.occurredAt - occurredAt));
-    const artifact = sortedCandidates[0];
-    if (!artifact) {
-        return null;
-    }
-    return hydrateCrashArtifact({
-        artifact,
-        recentLogLines,
-    });
-};
-const createAndroidLogEvent = (line, bundleId) => {
-    const startMatch = line.match(startProcPattern(bundleId));
-    if (startMatch) {
-        return {
-            type: 'app_started',
-            pid: Number(startMatch[1]),
-            source: 'logs',
-            line,
-        };
-    }
-    const processMatch = line.match(processPattern(bundleId));
-    if (processMatch) {
-        return {
-            type: 'possible_crash',
-            pid: Number(processMatch[1]),
-            source: 'logs',
-            line,
-            crashDetails: getAndroidLogLineCrashDetails({
-                line,
-                bundleId,
-                pid: Number(processMatch[1]),
-            }),
-        };
-    }
-    if (nativeCrashPattern(bundleId).test(line)) {
-        return {
-            type: 'possible_crash',
-            source: 'logs',
-            line,
-            crashDetails: getAndroidLogLineCrashDetails({
-                line,
-                bundleId,
-            }),
-        };
-    }
-    const diedMatch = line.match(processDiedPattern(bundleId));
-    if (diedMatch) {
-        return {
-            type: 'app_exited',
-            pid: Number(diedMatch[1]),
-            source: 'logs',
-            line,
-            crashDetails: getAndroidLogLineCrashDetails({
-                line,
-                bundleId,
-                pid: Number(diedMatch[1]),
-            }),
-        };
-    }
-    if (line.includes(bundleId) &&
-        /fatal|crash|signal 11|signal 6|backtrace/i.test(line)) {
-        return {
-            type: 'possible_crash',
-            source: 'logs',
-            line,
-            crashDetails: getAndroidLogLineCrashDetails({
-                line,
-                bundleId,
-            }),
-        };
-    }
-    return null;
-};
-export const createAndroidAppMonitor = ({ adbId, bundleId, appUid, crashArtifactWriter, }) => {
-    const emitter = getEmitter();
-    let isStarted = false;
-    let logcatProcess = null;
-    let logTask = null;
-    let recentLogLines = [];
-    let recentCrashArtifacts = [];
-    const emit = (event) => {
-        emitter.emit(event);
-    };
-    const recordLogLine = (line) => {
-        recentLogLines = [
-            ...recentLogLines,
-            { line, occurredAt: Date.now() },
-        ].slice(-MAX_RECENT_LOG_LINES);
-    };
-    const recordCrashArtifact = (details) => {
-        if (!details) {
-            return;
-        }
-        recentCrashArtifacts = [
-            ...recentCrashArtifacts,
-            createCrashArtifact({
-                details,
-                recentLogLines,
-            }),
-        ].slice(-MAX_RECENT_CRASH_ARTIFACTS);
-    };
-    const stopProcess = async (child) => {
-        if (!child) {
-            return;
-        }
-        try {
-            (await child.nodeChildProcess).kill();
-        }
-        catch {
-            // Ignore termination failures for background monitors.
-        }
-    };
-    const startLogcat = async () => {
-        const logcatTimestamp = await adb.getLogcatTimestamp(adbId);
-        logcatProcess = adb.startLogcat(adbId, getLogcatArgs(appUid, logcatTimestamp));
-        const currentProcess = logcatProcess;
-        if (!currentProcess) {
-            return;
-        }
-        logTask = (async () => {
-            try {
-                for await (const line of currentProcess) {
-                    recordLogLine(line);
-                    emit({ type: 'log', source: 'logs', line });
-                    const event = createAndroidLogEvent(line, bundleId);
-                    if (event) {
-                        if (event.type === 'possible_crash' ||
-                            event.type === 'app_exited') {
-                            recordCrashArtifact(event.crashDetails);
-                        }
-                        emit(event);
-                    }
-                }
-            }
-            catch (error) {
-                if (!(error instanceof SubprocessError && error.signalName === 'SIGTERM')) {
-                    androidAppMonitorLogger.debug('Android logcat monitor stopped', error);
-                }
-            }
-        })();
-    };
-    const start = async () => {
-        if (isStarted) {
-            return;
-        }
-        try {
-            await startLogcat();
-            isStarted = true;
-        }
-        catch (error) {
-            const currentProcess = logcatProcess;
-            const currentTask = logTask;
-            logcatProcess = null;
-            logTask = null;
-            await stopProcess(currentProcess);
-            await currentTask;
-            throw error;
-        }
-    };
-    const stop = async () => {
-        if (!isStarted) {
-            return;
-        }
-        isStarted = false;
-        const currentProcess = logcatProcess;
-        const currentTask = logTask;
-        logcatProcess = null;
-        logTask = null;
-        await stopProcess(currentProcess);
-        await currentTask;
-    };
-    const dispose = async () => {
-        await stop();
-        emitter.clearAllListeners();
-        recentLogLines = [];
-        recentCrashArtifacts = [];
-    };
-    const addListener = (listener) => {
-        emitter.addListener(listener);
-    };
-    const removeListener = (listener) => {
-        emitter.removeListener(listener);
-    };
-    return {
-        start,
-        stop,
-        dispose,
-        addListener,
-        removeListener,
-        getCrashDetails: async (options) => {
-            await new Promise((resolve) => setTimeout(resolve, CRASH_ARTIFACT_SETTLE_DELAY_MS));
-            const details = getLatestCrashArtifact({
-                crashArtifacts: recentCrashArtifacts,
-                recentLogLines,
-                ...options,
-            });
-            if (!details) {
-                return null;
-            }
-            return persistCrashArtifact({
-                details,
-                crashArtifactWriter,
-            });
-        },
-    };
-};
-export { createAndroidLogEvent };

package/dist/device-state.d.ts

@@ -1,6 +0,0 @@
-import type { DeviceStateController } from '@react-native-harness/platforms';
-export declare const createAndroidDeviceState: (options: {
-    adbId: string;
-    bundleId: string;
-}) => DeviceStateController;
-//# sourceMappingURL=device-state.d.ts.map

package/dist/device-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"device-state.d.ts","sourceRoot":"","sources":["../src/device-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EAEtB,MAAM,iCAAiC,CAAC;AA0HzC,eAAO,MAAM,wBAAwB,GAAI,SAAS;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAG,qBAqFH,CAAC"}

package/dist/device-state.js

@@ -1,142 +0,0 @@
-import * as adb from './adb.js';
-const ANDROID_PERMISSION_ALIASES = {
-    bluetooth: [
-        'android.permission.BLUETOOTH_CONNECT',
-        'android.permission.BLUETOOTH_SCAN',
-    ],
-    calendar: [
-        'android.permission.READ_CALENDAR',
-        'android.permission.WRITE_CALENDAR',
-    ],
-    camera: ['android.permission.CAMERA'],
-    contacts: [
-        'android.permission.READ_CONTACTS',
-        'android.permission.WRITE_CONTACTS',
-    ],
-    location: [
-        'android.permission.ACCESS_FINE_LOCATION',
-        'android.permission.ACCESS_COARSE_LOCATION',
-    ],
-    mediaLibrary: [
-        'android.permission.READ_MEDIA_IMAGES',
-        'android.permission.READ_MEDIA_VIDEO',
-        'android.permission.READ_MEDIA_AUDIO',
-    ],
-    microphone: ['android.permission.RECORD_AUDIO'],
-    notifications: ['android.permission.POST_NOTIFICATIONS'],
-    phone: [
-        'android.permission.CALL_PHONE',
-        'android.permission.ANSWER_PHONE_CALLS',
-    ],
-    sms: [
-        'android.permission.READ_SMS',
-        'android.permission.RECEIVE_SMS',
-        'android.permission.SEND_SMS',
-    ],
-    storage: [
-        'android.permission.READ_EXTERNAL_STORAGE',
-        'android.permission.WRITE_EXTERNAL_STORAGE',
-    ],
-};
-const normalizePermissionName = (name) => {
-    return name.trim();
-};
-const resolvePermissions = async (options) => {
-    if (options.command.kind === 'permission-all') {
-        return adb.getDeclaredDangerousPermissions(options.adbId, options.bundleId);
-    }
-    const normalized = normalizePermissionName(options.command.permission);
-    const aliases = ANDROID_PERMISSION_ALIASES[normalized];
-    if (aliases) {
-        return aliases;
-    }
-    return [normalized];
-};
-const snapshotPermissions = async (options) => {
-    const granted = await Promise.all(options.permissions.map(async (permission) => {
-        const isGranted = await adb.isPermissionGranted(options.adbId, options.bundleId, permission);
-        return isGranted ? permission : null;
-    }));
-    return granted.filter((permission) => permission != null);
-};
-const applyPermissionSnapshot = async (options) => {
-    const grantedSet = new Set(options.snapshot.previousGranted);
-    const toGrant = options.snapshot.permissions.filter((permission) => grantedSet.has(permission));
-    const toRevoke = options.snapshot.permissions.filter((permission) => !grantedSet.has(permission));
-    if (toGrant.length > 0) {
-        await adb.setPermissions(options.adbId, options.bundleId, toGrant, 'grant', {
-            bestEffort: true,
-        });
-    }
-    if (toRevoke.length > 0) {
-        await adb.setPermissions(options.adbId, options.bundleId, toRevoke, 'reset', {
-            bestEffort: true,
-        });
-    }
-};
-export const createAndroidDeviceState = (options) => {
-    const outstandingMutations = new Map();
-    let mutationCounter = 0;
-    const rememberMutation = (snapshot) => {
-        const id = `android-permissions-${++mutationCounter}`;
-        const mutation = {
-            id,
-            snapshot,
-            revert: async () => {
-                await controller.permissions.revert(id);
-            },
-        };
-        outstandingMutations.set(id, mutation);
-        return mutation;
-    };
-    const controller = {
-        permissions: {
-            apply: async (command) => {
-                const permissions = await resolvePermissions({
-                    adbId: options.adbId,
-                    bundleId: options.bundleId,
-                    command,
-                });
-                if (permissions.length === 0) {
-                    return { mutation: null };
-                }
-                const previousGranted = await snapshotPermissions({
-                    adbId: options.adbId,
-                    bundleId: options.bundleId,
-                    permissions,
-                });
-                await adb.setPermissions(options.adbId, options.bundleId, permissions, command.decision, { bestEffort: command.kind === 'permission-all' });
-                const mutation = rememberMutation({
-                    kind: 'permission-set',
-                    permissions,
-                    previousGranted,
-                });
-                return { mutation };
-            },
-            revert: async (mutationId) => {
-                const mutation = outstandingMutations.get(mutationId);
-                if (!mutation) {
-                    return;
-                }
-                outstandingMutations.delete(mutationId);
-                await applyPermissionSnapshot({
-                    adbId: options.adbId,
-                    bundleId: options.bundleId,
-                    snapshot: mutation.snapshot,
-                });
-            },
-            resetOutstanding: async () => {
-                const mutations = [...outstandingMutations.values()].reverse();
-                outstandingMutations.clear();
-                for (const mutation of mutations) {
-                    await applyPermissionSnapshot({
-                        adbId: options.adbId,
-                        bundleId: options.bundleId,
-                        snapshot: mutation.snapshot,
-                    });
-                }
-            },
-        },
-    };
-    return controller;
-};