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

package/dist/app-monitor.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,376 @@
+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/config.d.ts

@@ -68,8 +68,8 @@ export declare const AndroidEmulatorSchema: z.ZodObject<{
         } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    type: "emulator";
     name: string;
+    type: "emulator";
     avd?: {
         apiLevel: number;
         profile: string;
@@ -80,8 +80,8 @@ export declare const AndroidEmulatorSchema: z.ZodObject<{
         } | undefined;
     } | undefined;
 }, {
-    type: "emulator";
     name: string;
+    type: "emulator";
     avd?: {
         apiLevel: number;
         profile: string;
@@ -138,8 +138,8 @@ export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    type: "emulator";
     name: string;
+    type: "emulator";
     avd?: {
         apiLevel: number;
         profile: string;
@@ -150,8 +150,8 @@ export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         } | undefined;
     } | undefined;
 }, {
-    type: "emulator";
     name: string;
+    type: "emulator";
     avd?: {
         apiLevel: number;
         profile: string;
@@ -209,8 +209,8 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             } | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
-        type: "emulator";
         name: string;
+        type: "emulator";
         avd?: {
             apiLevel: number;
             profile: string;
@@ -221,8 +221,8 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             } | undefined;
         } | undefined;
     }, {
-        type: "emulator";
         name: string;
+        type: "emulator";
         avd?: {
             apiLevel: number;
             profile: string;
@@ -255,10 +255,11 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
         extras?: Record<string, string | number | boolean> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    bundleId: string;
     name: string;
     device: {
-        type: "emulator";
         name: string;
+        type: "emulator";
         avd?: {
             apiLevel: number;
             profile: string;
@@ -273,16 +274,16 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
         manufacturer: string;
         model: string;
     };
-    bundleId: string;
     activityName: string;
     appLaunchOptions?: {
         extras?: Record<string, string | number | boolean> | undefined;
     } | undefined;
 }, {
+    bundleId: string;
     name: string;
     device: {
-        type: "emulator";
         name: string;
+        type: "emulator";
         avd?: {
             apiLevel: number;
             profile: string;
@@ -297,7 +298,6 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
         manufacturer: string;
         model: string;
     };
-    bundleId: string;
     activityName?: string | undefined;
     appLaunchOptions?: {
         extras?: Record<string, string | number | boolean> | undefined;

package/dist/device-state.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,142 @@
+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;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@react-native-harness/platform-android",
   "description": "Android platform for React Native Harness",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,9 +19,9 @@
     "vite": "^7.2.2",
     "zod": "^3.25.67",
     "tslib": "^2.3.0",
-    "@react-native-harness/platforms": "1.5.0",
-    "@react-native-harness/tools": "1.5.0",
-    "@react-native-harness/config": "1.5.0"
+    "@react-native-harness/tools": "1.6.0",
+    "@react-native-harness/platforms": "1.6.0",
+    "@react-native-harness/config": "1.6.0"
   },
   "license": "MIT"
 }