appium-xcuitest-driver/build/lib/device/network-monitor-session.js

Appium driver for iOS using XCUITest for backend

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NetworkMonitorSession = void 0;
const models_1 = require("../commands/bidi/models");
const constants_1 = require("../commands/bidi/constants");
const remotexpc_utils_1 = require("./remotexpc-utils");
/**
 * Active DVT NetworkMonitor session: streams instrument events to the driver BiDi event bus.
 */
class NetworkMonitorSession {
    log;
    udid;
    dvt = null;
    runPromise = null;
    stopped = false;
    /**
     * @param log - Logger for this session (typically the driver logger).
     * @param udid - Target device UDID for `startDVTService`.
     */
    constructor(log, udid) {
        this.log = log;
        this.udid = udid;
    }
    /**
     * @returns `true` only while the consume loop may still be receiving events (`this.dvt` is set).
     * After normal completion, error, or {@link interrupt}, this becomes `false`.
     */
    isRunning() {
        return this.dvt !== null;
    }
    /**
     * Opens `startDVTService` and begins iterating `networkMonitor.events()`, emitting each payload on `eventEmitter`
     * using `BIDI_EVENT_NAME` and `makeNetworkMonitorEvent` (BiDi `appium:xcuitest.networkMonitor`).
     *
     * @param eventEmitter - Typically the session driver's `eventEmitter` (WebDriver BiDi bus).
     */
    async start(eventEmitter) {
        this.stopped = false;
        let dvt;
        try {
            const Services = await (0, remotexpc_utils_1.getRemoteXPCServices)();
            dvt = await Services.startDVTService(this.udid);
        }
        catch (err) {
            throw (0, remotexpc_utils_1.wrapRemoteXPCConnectionError)(err, `Failed to start network monitor via RemoteXPC for '${this.udid}'`);
        }
        this.dvt = dvt;
        this.runPromise = this.consumeEvents(dvt, eventEmitter);
    }
    /**
     * Stops monitoring and waits for the consume loop to finish. DVT is closed in
     * {@link consumeEvents} after the network monitor iterator exits (same pattern as
     * condition inducer `disable()` → `close()`).
     */
    async interrupt() {
        if (this.stopped) {
            return;
        }
        this.stopped = true;
        const dvt = this.dvt;
        const runPromise = this.runPromise;
        this.dvt = null;
        this.runPromise = null;
        if (dvt) {
            try {
                await dvt.networkMonitor.stop();
            }
            catch (err) {
                this.log.debug(`Error stopping network monitor: ${err?.message ?? err}`);
            }
        }
        if (runPromise) {
            try {
                await runPromise;
            }
            catch (err) {
                this.log.debug(`Error while finishing network monitor consume loop: ${err?.message ?? err}`);
            }
        }
    }
    async consumeEvents(dvt, eventEmitter) {
        try {
            for await (const event of dvt.networkMonitor.events()) {
                eventEmitter.emit(constants_1.BIDI_EVENT_NAME, (0, models_1.makeNetworkMonitorEvent)(event));
            }
        }
        catch (err) {
            if (!this.stopped) {
                this.log.error('Network monitor stream ended unexpectedly', err);
            }
        }
        finally {
            await this.closeDvt(dvt);
        }
    }
    async closeDvt(dvt) {
        try {
            await dvt.dvtService.close();
        }
        catch (err) {
            this.log.debug(`Error closing DVT service for network monitor: ${err?.message ?? err}`);
        }
    }
}
exports.NetworkMonitorSession = NetworkMonitorSession;
//# sourceMappingURL=network-monitor-session.js.map