@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/src/services/logcat/SessionDeviceLogs.js

@@ -0,0 +1,271 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionDeviceLogs = exports.WRITE_BATCH = exports.FLUSH_INTERVAL_MS = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const prisma_1 = require("../../prisma");
+const PluginContext_1 = require("../../PluginContext");
+const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
+const LogcatStreamService_1 = require("../../device-managers/android/LogcatStreamService");
+const adbForPhone_1 = require("../network/adbForPhone");
+const deviceLogBook_1 = require("./deviceLogBook");
+/** How often a session's new lines are written. */
+exports.FLUSH_INTERVAL_MS = 5000;
+/** Lines per write, and how many waiting lines start one before the interval. */
+exports.WRITE_BATCH = 500;
+/** The phone's `date`, read once a session; one that hangs this long is unknown. */
+const CLOCK_TIMEOUT_MS = 5000;
+/** Waits before opening the phone's log stream again: doubling from the first, up to the last. */
+const RETRY_FIRST_MS = 1000;
+const RETRY_MAX_MS = 30000;
+/**
+ * The session page's Device logs for a session on this server's own Android
+ * phone: its lines from start to end, each once, with its own time and level,
+ * up to a limit (DeviceLogBook).
+ *
+ * The session listens to the phone's log stream (LogcatStreamService, one
+ * `adb logcat` per phone, which the device page's Logs viewer may share) from
+ * EventManager's start, once the session's row exists, to its stop, which
+ * every ending reaches. While it listens, the stream has a viewer, so its idle
+ * stop leaves it running; afterwards it stops 30 s after its last viewer, as
+ * ever. The session never stops or restarts it. If the stream ends (the phone
+ * restarted, or was unplugged), the session opens it again and notes the gap.
+ *
+ * Until 2.14 each recorded command dumped the last 500 lines (`logcat -d`),
+ * kept the last 100 and skipped as many as the previous dump had given, so
+ * after the first command nothing more was ever saved, each line stamped with
+ * the time it was saved.
+ */
+let SessionDeviceLogs = class SessionDeviceLogs {
+    constructor() {
+        this.log = logger_1.default.scope('DeviceLogs');
+        this.running = new Map();
+    }
+    /** Whether a session on this phone is recorded: an Android phone (or emulator) this server drives. */
+    appliesTo(device) {
+        var _a;
+        if (!device || device.cloud)
+            return false;
+        if (String((_a = device.platform) !== null && _a !== void 0 ? _a : '').toLowerCase() !== 'android')
+            return false;
+        // A node's phone isn't reachable with this server's adb; the node has
+        // the session, and no row for it.
+        const ctx = this.context();
+        return (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(ctx.pluginArgs, ctx.port), ctx.nodeId, device);
+    }
+    /**
+     * Starts recording the session's device log. Resolves once it listens to
+     * the phone's stream (or is waiting to try again); callers needn't wait.
+     */
+    start({ sessionId, device, since }) {
+        var _a, _b;
+        if (this.running.has(sessionId) || !this.appliesTo(device))
+            return Promise.resolve();
+        const entry = {
+            udid: device.udid,
+            buffer: [],
+            flushTimer: setInterval(() => void this.write(sessionId, entry), this.flushIntervalMs()),
+            writing: Promise.resolve(),
+            lastCreatedAt: 0,
+            attempts: 0,
+            stopped: false,
+        };
+        (_b = (_a = entry.flushTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.running.set(sessionId, entry);
+        this.log.info(`[${sessionId}] Recording the device log of ${device.udid}`);
+        return this.open(sessionId, entry, since !== null && since !== void 0 ? since : Date.now()).catch((err) => { var _a; return this.log.warn(`[${sessionId}] Device log not recorded: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); });
+    }
+    /** Stops listening and writes what is left. Idempotent. */
+    stop(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const entry = this.running.get(sessionId);
+            if (!entry)
+                return;
+            this.running.delete(sessionId);
+            entry.stopped = true;
+            clearInterval(entry.flushTimer);
+            if (entry.retryTimer)
+                clearTimeout(entry.retryTimer);
+            (_a = entry.remove) === null || _a === void 0 ? void 0 : _a.call(entry);
+            entry.remove = undefined;
+            if (entry.book)
+                entry.buffer.push(...entry.book.finish(new Date()));
+            yield this.write(sessionId, entry);
+        });
+    }
+    /** Whether the session is recorded here. */
+    isRecording(sessionId) {
+        return this.running.has(sessionId);
+    }
+    open(sessionId, entry, since) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let clock = null;
+            try {
+                clock = yield this.readClock(entry.udid);
+            }
+            catch (err) {
+                this.log.debug(`[${sessionId}] Can't read the clock of ${entry.udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            if (!clock) {
+                this.log.warn(`[${sessionId}] The clock of ${entry.udid} is unknown; its log lines are read as this server's time`);
+            }
+            if (entry.stopped)
+                return;
+            entry.book = new deviceLogBook_1.DeviceLogBook({ since, clock: clock !== null && clock !== void 0 ? clock : deviceLogBook_1.UNKNOWN_CLOCK });
+            yield this.listen(sessionId, entry);
+        });
+    }
+    listen(sessionId, entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            entry.retryTimer = undefined;
+            if (entry.stopped)
+                return;
+            let mux;
+            try {
+                mux = yield this.streams().start(entry.udid);
+            }
+            catch (err) {
+                if (entry.attempts === 0) {
+                    this.log.warn(`[${sessionId}] Can't open the device log of ${entry.udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. Trying again.`);
+                }
+                this.retry(sessionId, entry);
+                return;
+            }
+            // Stopped while the stream started: leave it to its own idle stop.
+            if (entry.stopped)
+                return;
+            const book = entry.book;
+            let delivered = false;
+            const remove = mux.addClient((rec) => {
+                if (rec.synthetic)
+                    return;
+                if (!delivered) {
+                    delivered = true;
+                    entry.attempts = 0;
+                }
+                const rows = book.add(rec);
+                if (rows.length === 0)
+                    return;
+                entry.buffer.push(...rows);
+                if (entry.buffer.length >= exports.WRITE_BATCH)
+                    void this.write(sessionId, entry);
+            }, 
+            // Never refused: what the session keeps is bounded by its book.
+            () => true, () => {
+                if (entry.remove === remove)
+                    entry.remove = undefined;
+                if (entry.stopped)
+                    return;
+                const note = book.interrupted(new Date());
+                // A stream that delivered nothing (a phone that's gone) isn't noted
+                // again on every try.
+                if (delivered) {
+                    entry.buffer.push(...note);
+                    this.log.info(`[${sessionId}] The device log of ${entry.udid} ended; opening it again`);
+                }
+                this.retry(sessionId, entry);
+            });
+            entry.remove = remove;
+        });
+    }
+    retry(sessionId, entry) {
+        var _a, _b;
+        if (entry.stopped || entry.retryTimer)
+            return;
+        entry.attempts += 1;
+        const delay = Math.min(this.retryFirstMs() * 2 ** (entry.attempts - 1), RETRY_MAX_MS);
+        entry.retryTimer = setTimeout(() => void this.listen(sessionId, entry), delay);
+        (_b = (_a = entry.retryTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Writes what is waiting, WRITE_BATCH rows at a time. On a failure the rows
+     * wait for the next write: the book bounds how many there can be.
+     */
+    write(sessionId, entry) {
+        entry.writing = entry.writing.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            while (entry.buffer.length > 0) {
+                const batch = entry.buffer.splice(0, exports.WRITE_BATCH);
+                // The session's rows are read in `createdAt` order, so each is a
+                // millisecond after the one before: the lines of one moment (a stack
+                // trace's) keep their order whatever the database.
+                const first = Math.max(Date.now(), entry.lastCreatedAt + 1);
+                try {
+                    yield this.writeLines(sessionId, batch, first);
+                    entry.lastCreatedAt = first + batch.length - 1;
+                }
+                catch (err) {
+                    entry.buffer.unshift(...batch);
+                    this.log.warn(`[${sessionId}] Writing ${batch.length} device log lines failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                    return;
+                }
+            }
+        }));
+        return entry.writing;
+    }
+    // ---------------------------------------------------------------------
+    // Seams. Overridden by tests; the defaults are the real thing.
+    // ---------------------------------------------------------------------
+    context() {
+        return typedi_1.Container.get(PluginContext_1.PluginContext);
+    }
+    streams() {
+        return typedi_1.Container.get(LogcatStreamService_1.LogcatStreamService);
+    }
+    flushIntervalMs() {
+        return exports.FLUSH_INTERVAL_MS;
+    }
+    retryFirstMs() {
+        return RETRY_FIRST_MS;
+    }
+    /** The phone's clock against this server's, or null if its answer isn't one. */
+    readClock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield (0, adbForPhone_1.adbForPhone)(udid);
+            const asked = Date.now();
+            // One word: the phone's shell would take a second one as a time to set.
+            const out = yield adb.adbExec(['-s', udid, 'shell', deviceLogBook_1.DEVICE_CLOCK_COMMAND], {
+                timeout: CLOCK_TIMEOUT_MS,
+            });
+            return (0, deviceLogBook_1.parseDeviceClock)(String(out !== null && out !== void 0 ? out : ''), (asked + Date.now()) / 2);
+        });
+    }
+    writeLines(sessionId, lines, firstCreatedAt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.log.createMany({
+                data: lines.map((line, i) => ({
+                    session_id: sessionId,
+                    log_type: 'DEVICE',
+                    message: line.message,
+                    timestamp: line.timestamp,
+                    createdAt: new Date(firstCreatedAt + i),
+                })),
+            });
+        });
+    }
+};
+exports.SessionDeviceLogs = SessionDeviceLogs;
+exports.SessionDeviceLogs = SessionDeviceLogs = __decorate([
+    (0, typedi_1.Service)()
+], SessionDeviceLogs);

package/lib/src/services/logcat/deviceLogBook.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceLogBook = exports.DEVICE_CLOCK_COMMAND = exports.UNKNOWN_CLOCK = exports.WINDOW_SLACK_MS = exports.DEVICE_LOG_ERROR_LIMIT = exports.DEVICE_LOG_LINE_LIMIT = void 0;
+exports.parseDeviceClock = parseDeviceClock;
+exports.formatThreadtime = formatThreadtime;
+const logcatParse_1 = require("./logcatParse");
+/**
+ * Which of a phone's log records a session keeps, and as what. Pure: the
+ * service (SessionDeviceLogs) feeds it the records of the phone's shared log
+ * stream and writes what it returns.
+ *
+ * - **The session's lines only.** The stream starts with up to 2000 lines of
+ *   history (`-T`, or the multiplexer's replay to a late joiner), so a line
+ *   counts from shortly before the phone was given to the session.
+ * - **Its own time, on this server's clock.** A line is stamped with the
+ *   moment the phone logged it, moved by the phone's clock offset, so it
+ *   lines up with the session's commands; its text keeps the time the phone
+ *   printed. A phone's clock is often seconds off, and one with no network
+ *   time can be minutes off.
+ * - **Each line once.** A stream delivers a record once. When the stream
+ *   ends mid-session and is started again, its history overlaps what was
+ *   kept, so a resumed stream counts only lines after the newest one seen,
+ *   compared by time and, at that same millisecond, by content.
+ * - **Bounded.** DEVICE_LOG_LINE_LIMIT lines of any level, then errors only
+ *   (a crash's "FATAL EXCEPTION" is an error) up to DEVICE_LOG_ERROR_LIMIT
+ *   more, each step said in the log itself.
+ */
+/** Lines of any level a session keeps. */
+exports.DEVICE_LOG_LINE_LIMIT = 10000;
+/** Errors (E and F) kept after DEVICE_LOG_LINE_LIMIT; nothing more after them. */
+exports.DEVICE_LOG_ERROR_LIMIT = 2000;
+/**
+ * How long before the phone was given to the session a line may be and still
+ * count: the phone's clock offset, read once, is only about that good.
+ */
+exports.WINDOW_SLACK_MS = 2000;
+/** A phone whose clock couldn't be read: taken to be this server's. */
+exports.UNKNOWN_CLOCK = { zoneShiftMs: 0, skewMs: 0 };
+const QUARTER_HOUR_MS = 15 * 60000;
+/**
+ * The phone's `date` command for {@link parseDeviceClock}: seconds since the
+ * epoch, nanoseconds, and the local time logcat prints, at one instant, with
+ * no spaces (it goes through the phone's shell as one word). An older
+ * toybox prints no nanoseconds.
+ */
+exports.DEVICE_CLOCK_COMMAND = 'date +%s.%N.%m-%d.%H:%M:%S';
+/**
+ * The phone's clock from {@link DEVICE_CLOCK_COMMAND}'s output, or null if it
+ * isn't that. `hostNowMs` is this server's time when the phone answered.
+ *
+ * The local time is read the way parseThreadtimeLine reads a log line, so the
+ * difference to the phone's epoch is exactly the shift its lines need,
+ * whatever either time zone is. Rounded to a quarter hour: time zones differ
+ * by whole quarters.
+ */
+function parseDeviceClock(output, hostNowMs) {
+    const m = /(\d{9,})\.(\S*?)\.(\d{2})-(\d{2})\.(\d{2}):(\d{2}):(\d{2})/.exec(output);
+    if (!m)
+        return null;
+    const [, secs, nanos, mo, d, h, mi, s] = m;
+    const asLogged = (0, logcatParse_1.parseThreadtimeLine)(`${mo}-${d} ${h}:${mi}:${s}.000     0     0 I clock: now`, new Date(hostNowMs));
+    if (!asLogged)
+        return null;
+    // Without nanoseconds, the phone's instant was within the second after `%s`.
+    const fraction = /^\d{9}$/.test(nanos) ? Math.floor(Number(nanos) / 1e6) : 500;
+    const phoneNow = Number(secs) * 1000 + fraction;
+    return {
+        zoneShiftMs: Math.round((phoneNow - asLogged.ts) / QUARTER_HOUR_MS) * QUARTER_HOUR_MS,
+        skewMs: hostNowMs - phoneNow,
+    };
+}
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+/**
+ * A record as logcat's threadtime format prints it (logprint.cpp,
+ * `"%s %5d %5d %c %-8s: "`): the time as the phone printed it, then the pid,
+ * the tid, the level, the tag and the message. The dashboard reads the level
+ * from this text (log-derive.ts), and it is what Android developers know.
+ */
+function formatThreadtime(rec) {
+    // `ts` was built from the printed fields as this server's local time, so
+    // its local fields are the printed ones.
+    const t = new Date(rec.ts);
+    const time = `${pad(t.getMonth() + 1)}-${pad(t.getDate())} ` +
+        `${pad(t.getHours())}:${pad(t.getMinutes())}:${pad(t.getSeconds())}.${pad(t.getMilliseconds(), 3)}`;
+    const pid = String(rec.pid).padStart(5);
+    const tid = String(rec.tid).padStart(5);
+    return `${time} ${pid} ${tid} ${rec.level} ${rec.tag.padEnd(8)}: ${rec.message}`;
+}
+const count = (n) => n.toLocaleString('en-US');
+const keyOf = (r) => `${r.pid} ${r.tid} ${r.level} ${r.tag} ${r.message}`;
+const isError = (r) => r.level === 'E' || r.level === 'F';
+class DeviceLogBook {
+    constructor(opts) {
+        var _a, _b;
+        this.kept = 0;
+        this.leftOut = 0;
+        this.limitNoted = false;
+        this.clock = opts.clock;
+        this.lineLimit = (_a = opts.lineLimit) !== null && _a !== void 0 ? _a : exports.DEVICE_LOG_LINE_LIMIT;
+        this.errorLimit = (_b = opts.errorLimit) !== null && _b !== void 0 ? _b : exports.DEVICE_LOG_ERROR_LIMIT;
+        // A record at `ts` was logged at ts + zoneShift + skew by this server's
+        // clock (timeOf); it counts from WINDOW_SLACK_MS before `since`.
+        const first = opts.since - exports.WINDOW_SLACK_MS - this.clock.zoneShiftMs - this.clock.skewMs;
+        this.floor = { ts: Math.ceil(first), keys: new Set() };
+    }
+    /** The rows a record adds: none, its own, or a note before it. */
+    add(rec) {
+        // The stream's own notes (a slow viewer's dropped lines, its end) aren't
+        // the phone's; the service notes an interruption itself.
+        if (rec.synthetic)
+            return [];
+        const key = keyOf(rec);
+        if (rec.ts < this.floor.ts || (rec.ts === this.floor.ts && this.floor.keys.has(key))) {
+            return [];
+        }
+        if (!this.newest || rec.ts > this.newest.ts)
+            this.newest = { ts: rec.ts, keys: new Set([key]) };
+        else if (rec.ts === this.newest.ts)
+            this.newest.keys.add(key);
+        const out = [];
+        if (this.kept >= this.lineLimit && !this.limitNoted) {
+            this.limitNoted = true;
+            out.push(this.note(`This session reached ${count(this.lineLimit)} device log lines. ` +
+                'From here on, only errors are kept.', this.timeOf(rec)));
+        }
+        const room = this.kept < this.lineLimit || (isError(rec) && this.kept < this.lineLimit + this.errorLimit);
+        if (room) {
+            this.kept += 1;
+            out.push({ message: formatThreadtime(rec), timestamp: this.timeOf(rec) });
+        }
+        else {
+            this.leftOut += 1;
+        }
+        return out;
+    }
+    /**
+     * The stream ended while the session runs. The next one starts with
+     * history, so it may deliver only what is newer than what was seen.
+     */
+    interrupted(at) {
+        if (this.newest)
+            this.floor = { ts: this.newest.ts, keys: new Set(this.newest.keys) };
+        return [this.note("The phone's log was interrupted. Lines may be missing from here.", at)];
+    }
+    /** The session ended: what was left out, if anything. */
+    finish(at) {
+        if (this.leftOut === 0)
+            return [];
+        const lines = this.leftOut === 1 ? '1 device log line was' : `${count(this.leftOut)} device log lines were`;
+        return [this.note(`${lines} left out to keep this session's log within its limit.`, at)];
+    }
+    /** Lines kept so far. */
+    get keptLines() {
+        return this.kept;
+    }
+    timeOf(rec) {
+        return new Date(rec.ts + this.clock.zoneShiftMs + this.clock.skewMs);
+    }
+    note(text, at) {
+        return { message: `Xenon: ${text}`, timestamp: at };
+    }
+}
+exports.DeviceLogBook = DeviceLogBook;

package/lib/src/services/network/AndroidRadios.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidRadios = void 0;
+/**
+ * A phone's Wi-Fi and mobile data, through the resolved adb (`adbExec`: no
+ * shell, no bare `adb`).
+ */
+class AndroidRadios {
+    constructor(getAdb) {
+        this.getAdb = getAdb;
+    }
+    /**
+     * `wifi_on` is 1 or 2 when Wi-Fi is on (2: on in spite of airplane mode),
+     * 0 or 3 when it is off. `mobile_data` is 1 or 0. Anything else, or a read
+     * that fails, is null: "don't know".
+     */
+    read(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.getAdb(udid);
+            const get = (name) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const out = yield adb.adbExec(['-s', udid, 'shell', 'settings', 'get', 'global', name]);
+                    return String(out !== null && out !== void 0 ? out : '').trim();
+                }
+                catch (_a) {
+                    return null;
+                }
+            });
+            const wifi = yield get('wifi_on');
+            const data = yield get('mobile_data');
+            return {
+                wifiOn: wifi === '1' || wifi === '2' ? true : wifi === '0' || wifi === '3' ? false : null,
+                dataOn: data === '1' ? true : data === '0' ? false : null,
+            };
+        });
+    }
+    /** Mobile data, then Wi-Fi, off. */
+    turnOff(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.getAdb(udid);
+            yield adb.adbExec(['-s', udid, 'shell', 'svc', 'data', 'disable']);
+            yield adb.adbExec(['-s', udid, 'shell', 'svc', 'wifi', 'disable']);
+        });
+    }
+    /** Turns on the ones asked for; leaves the others as they are. */
+    turnOn(udid, which) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!which.data && !which.wifi)
+                return;
+            const adb = yield this.getAdb(udid);
+            if (which.data)
+                yield adb.adbExec(['-s', udid, 'shell', 'svc', 'data', 'enable']);
+            if (which.wifi)
+                yield adb.adbExec(['-s', udid, 'shell', 'svc', 'wifi', 'enable']);
+        });
+    }
+    /** What to turn back on after Offline: what was on, and what nobody knew about. */
+    static toRestore(prior) {
+        return { data: prior.dataOn !== false, wifi: prior.wifiOn !== false };
+    }
+}
+exports.AndroidRadios = AndroidRadios;