@xenon-device-management/xenon 1.26.2 → 1.28.0

package/lib/src/app/routers/control.js

@@ -70,6 +70,7 @@ const streamType_1 = require("./streamType");
 const iosStreamPort_1 = require("./iosStreamPort");
 const androidH264Config_1 = require("./androidH264Config");
 const recording_store_1 = require("../../services/recording/recording-store");
+const clipboardErrors_1 = require("../../device-managers/clipboardErrors");
 const scopeGuard_1 = require("../../middleware/scopeGuard");
 const roleGuard_1 = require("../../middleware/roleGuard");
 const deviceAccessGuard_1 = require("../../middleware/deviceAccessGuard");
@@ -360,6 +361,10 @@ router.post('/:udid/clipboard', (req, res) => __awaiter(void 0, void 0, void 0,
             return res.status(200).send({ success: true });
         }
         catch (err) {
+            // The device can't do it at all (Android): 501, not a failure to retry.
+            if (err instanceof clipboardErrors_1.ClipboardUnsupportedError) {
+                return res.status(501).send({ error: err.message });
+            }
             logger_1.default.error(`Manual control setClipboard failed: ${err.message}`);
             return res.status(500).send({ error: err.message });
         }

package/lib/src/device-managers/AndroidDeviceManager.js

@@ -58,6 +58,8 @@ const displayState_1 = require("./android/displayState");
 const networkAddresses_1 = require("../helpers/networkAddresses");
 const appium_adb_1 = require("appium-adb");
 const logger_1 = __importDefault(require("../logger"));
+const clipboardBroadcast_1 = require("./android/clipboardBroadcast");
+const clipboardErrors_1 = require("./clipboardErrors");
 const lodash_1 = __importDefault(require("lodash"));
 const support_1 = require("@appium/support");
 const ChromeDriverManager_1 = __importDefault(require("./ChromeDriverManager"));
@@ -837,108 +839,42 @@ let AndroidDeviceManager = class AndroidDeviceManager {
             }
         });
     }
+    /**
+     * Reads the clipboard through Appium Settings. Android 10+ lets only the
+     * default input method read it, so Appium Settings is the IME for the length
+     * of one broadcast (see withAppiumIME). Failures are thrown, not swallowed:
+     * an empty string used to stand for both "empty" and "couldn't read".
+     */
     getClipboard(udid) {
         return __awaiter(this, void 0, void 0, function* () {
             const { adbInstance } = yield this.getAdb();
             if (!adbInstance)
-                return '';
-            try {
-                // Wrap the targeted broadcast in the Appium IME context
-                return yield this.withAppiumIME(adbInstance, udid, () => __awaiter(this, void 0, void 0, function* () {
-                    // 1. Try Targeted Broadcast method (Reliable for modern Android)
-                    const result = yield adbInstance.adbExec([
-                        '-s',
-                        udid,
-                        'shell',
-                        'am',
-                        'broadcast',
-                        '-a',
-                        'com.appium.settings.clipboard.get',
-                        '-n',
-                        'io.appium.settings/.receivers.ClipboardReceiver',
-                    ]);
-                    // Parse result like: Broadcast completed: result=-1, data="BASE64_DATA"
-                    const dataMatch = /data="([^"]*)"/.exec(result);
-                    if (dataMatch) {
-                        const rawData = dataMatch[1];
-                        if (!rawData)
-                            return '';
-                        // Appium Settings returns Base64 for robustness
-                        try {
-                            const decoded = Buffer.from(rawData, 'base64').toString('utf8');
-                            // If it looks like printable text after decoding, use it
-                            if (/^[\x20-\x7E\s\u00A0-\uFFFF]*$/.test(decoded))
-                                return decoded;
-                            return rawData;
-                        }
-                        catch (e) {
-                            return rawData;
-                        }
-                    }
-                    // 2. Fallback: Query the content provider (Legacy/Alternative)
-                    const queryResult = yield adbInstance.adbExec([
-                        '-s',
-                        udid,
-                        'shell',
-                        'content',
-                        'query',
-                        '--uri',
-                        'content://io.appium.settings.clipboard/clipboard',
-                    ]);
-                    // Extract value using a more flexible regex that handles different formats
-                    const valMatch = /value=([^\s,]*)/i.exec(queryResult);
-                    if (valMatch) {
-                        const val = valMatch[1];
-                        // Most content providers return base64 for safety
-                        try {
-                            const decoded = Buffer.from(val, 'base64').toString('utf8');
-                            // Basic sanity check: if it contains non-printable characters, it might not have been base64
-                            if (/^[\x20-\x7E\s]*$/.test(decoded))
-                                return decoded;
-                            return val;
-                        }
-                        catch (e) {
-                            return val;
-                        }
-                    }
-                    return '';
-                }));
-            }
-            catch (err) {
-                logger_1.default.warn(`Failed to fetch Android clipboard for ${udid}: ${err instanceof Error ? err.message : err}`);
-            }
-            return '';
+                throw new Error('ADB is not available');
+            const output = yield this.withAppiumIME(adbInstance, udid, () => adbInstance.adbExec([
+                '-s',
+                udid,
+                'shell',
+                'am',
+                'broadcast',
+                '-n',
+                clipboardBroadcast_1.CLIPBOARD_RECEIVER,
+                '-a',
+                clipboardBroadcast_1.CLIPBOARD_GET_ACTION,
+            ]));
+            return (0, clipboardBroadcast_1.parseClipboardBroadcast)(output);
         });
     }
-    setClipboard(udid, content) {
+    /**
+     * Not possible on Android outside a test session. Appium Settings, the only
+     * helper Xenon can use here, has no clipboard-set action (8.0.5 holds just
+     * io.appium.settings.clipboard.get), and Appium itself sets the clipboard
+     * through a running UiAutomator2 session. The old broadcast reached the
+     * *read* receiver, which answered OK, so writes reported success and changed
+     * nothing.
+     */
+    setClipboard() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { adbInstance } = yield this.getAdb();
-            if (!adbInstance)
-                return;
-            try {
-                yield this.withAppiumIME(adbInstance, udid, () => __awaiter(this, void 0, void 0, function* () {
-                    yield adbInstance.adbExec([
-                        '-s',
-                        udid,
-                        'shell',
-                        'am',
-                        'broadcast',
-                        '-a',
-                        'com.appium.settings.clipboard.set',
-                        '-n',
-                        'io.appium.settings/.receivers.ClipboardReceiver',
-                        '--es',
-                        'label',
-                        'clipboard',
-                        '--es',
-                        'content',
-                        Buffer.from(content).toString('base64'), // Send as Base64 for safety
-                    ]);
-                }));
-            }
-            catch (err) {
-                logger_1.default.warn(`Failed to set Android clipboard for ${udid}: ${err instanceof Error ? err.message : err}`);
-            }
+            throw new clipboardErrors_1.ClipboardUnsupportedError('Android doesn’t allow setting the clipboard from here: Appium Settings can only read it.');
         });
     }
     touchAndHold(udid, x, y, duration) {

package/lib/src/device-managers/HealthMonitorService.js

@@ -159,15 +159,17 @@ let HealthMonitorService = class HealthMonitorService {
                         let hasActiveManualStream = false;
                         try {
                             if (['ios', 'tvos'].includes(device.platform)) {
-                                yield Promise.resolve().then(() => __importStar(require('./ios/IOSStreamService')));
-                                const iosStream = typedi_1.Container.get('IOSStreamService');
+                                // By class: TypeDI 0.10 ignores @Service({ name }), so a lookup
+                                // by name always threw here and this check never saw a stream.
+                                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./ios/IOSStreamService')));
+                                const iosStream = typedi_1.Container.get(IOSStreamService);
                                 const streamStatus = iosStream.getStreamStatus(device.udid);
                                 hasActiveManualStream = !!(streamStatus &&
                                     (streamStatus.status === 'running' || streamStatus.status === 'starting'));
                             }
                             else if (device.platform === 'android') {
-                                yield Promise.resolve().then(() => __importStar(require('./android/AndroidStreamService')));
-                                const androidStream = typedi_1.Container.get('AndroidStreamService');
+                                const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./android/AndroidStreamService')));
+                                const androidStream = typedi_1.Container.get(AndroidStreamService);
                                 const streamStatus = androidStream.getStreamStatus(device.udid);
                                 hasActiveManualStream = !!(streamStatus &&
                                     (streamStatus.status === 'running' || streamStatus.status === 'starting'));
@@ -205,10 +207,12 @@ let HealthMonitorService = class HealthMonitorService {
                                 let hasStreamNow = false;
                                 try {
                                     if (['ios', 'tvos'].includes(device.platform)) {
-                                        hasStreamNow = !!typedi_1.Container.get('IOSStreamService').getStreamStatus(device.udid);
+                                        const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./ios/IOSStreamService')));
+                                        hasStreamNow = !!typedi_1.Container.get(IOSStreamService).getStreamStatus(device.udid);
                                     }
                                     else if (device.platform === 'android') {
-                                        hasStreamNow = !!typedi_1.Container.get('AndroidStreamService').getStreamStatus(device.udid);
+                                        const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./android/AndroidStreamService')));
+                                        hasStreamNow = !!typedi_1.Container.get(AndroidStreamService).getStreamStatus(device.udid);
                                     }
                                 }
                                 catch (e) {

package/lib/src/device-managers/android/AndroidH264StreamService.js

@@ -62,6 +62,7 @@ const H264Multiplexer_1 = require("./H264Multiplexer");
 const h264NalParser_1 = require("./h264NalParser");
 const androidH264Config_1 = require("../../app/routers/androidH264Config");
 const PluginContext_1 = require("../../PluginContext");
+const previewHold_1 = require("./previewHold");
 const IDLE_TIMEOUT_MS = 600000; // stop a stream after 10 min with zero viewers
 const RESTART_MIN_INTERVAL_MS = 300; // fast restart after a healthy stream hits the cap/rotation
 // After this many consecutive restarts that produced no frames (device gone,
@@ -103,7 +104,11 @@ let AndroidH264StreamService = class AndroidH264StreamService {
                 }
                 else if (now - s.emptyAt > IDLE_TIMEOUT_MS) {
                     logger_1.default.info(`[${udid}] Stopping idle H.264 stream (no viewers for ${IDLE_TIMEOUT_MS}ms)`);
-                    this.stop(udid);
+                    // The stream went, but the live-preview hold stayed: with H.264
+                    // preview, a tab closed without releasing kept the device busy for
+                    // good. stop() itself must not release (a recording starting calls
+                    // it); an idle stop does, if nothing else uses the device.
+                    void this.stop(udid).then(() => (0, previewHold_1.releaseIdlePreviewHold)(udid));
                 }
             }
         }, 60000);

package/lib/src/device-managers/android/AndroidStreamService.js

@@ -59,7 +59,6 @@ const http_1 = __importDefault(require("http"));
 const sharp_1 = __importDefault(require("sharp"));
 const logger_1 = __importDefault(require("../../logger"));
 const device_store_1 = require("../../data-service/device-store");
-const device_service_1 = require("../../data-service/device-service");
 const DeviceLockManager_1 = require("./DeviceLockManager");
 const typedi_1 = require("typedi");
 const ResourceIsolationService_1 = require("../../services/ResourceIsolationService");
@@ -67,6 +66,7 @@ const PortAllocator_1 = require("../../services/PortAllocator");
 const ffmpegPath_1 = require("../../helpers/ffmpegPath");
 const singleFlight_1 = require("../../helpers/singleFlight");
 const androidStreamReuse_1 = require("./androidStreamReuse");
+const previewHold_1 = require("./previewHold");
 // JPEG quality for the in-process sharp encoder (0-100). ~78 approximates the
 // old ffmpeg `-q:v 8` (mjpeg quantizer scale) — the low-lag/quality knob.
 const JPEG_QUALITY = 78;
@@ -90,7 +90,9 @@ let AndroidStreamService = class AndroidStreamService {
                     }
                 }
             }
-        }), 3600000);
+            // Every minute, not every hour: an hourly check left an abandoned
+            // preview hold in place for up to 70 minutes. The loop is in memory.
+        }), 60000);
     }
     /**
      * Resolve the actual adb binary path (and remote-host args) via the same
@@ -400,7 +402,6 @@ let AndroidStreamService = class AndroidStreamService {
     }
     stopStream(udid) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const session = this.sessions.get(udid);
             if (session) {
                 session.status = 'stopped';
@@ -408,21 +409,11 @@ let AndroidStreamService = class AndroidStreamService {
                     session.server.close();
                     session.server = null;
                 }
-                // Principal Fix: Only release the device lock if THIS STREAM SERVICE owns it.
-                // If an Appium automation session owns the lock, don't touch it.
-                try {
-                    const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
-                    if (device && ((_a = device.session_id) === null || _a === void 0 ? void 0 : _a.startsWith('manual_'))) {
-                        logger_1.default.info(`[${udid}] Stream Stop: Releasing manual control lock.`);
-                        yield (0, device_service_1.unblockDevice)(udid, device.host);
-                    }
-                    else if (device && device.busy) {
-                        logger_1.default.info(`[${udid}] Stream Stop: Device busy with session ${device.session_id}. NOT releasing lock.`);
-                    }
-                }
-                catch (e) {
-                    /* Ignore unblocking failure on stop */
-                }
+                // Release the live-preview hold only if nothing else uses the device:
+                // one hold covers both transports, so an idle MJPEG stream must not drop
+                // it under someone watching over H.264, nor under a recording. An
+                // Appium session's lock is never a preview hold and is never touched.
+                yield (0, previewHold_1.releaseIdlePreviewHold)(udid);
                 // Release the mjpeg port lease this stream acquired in startStream, so the
                 // allocator can reuse the port immediately instead of waiting out the lease
                 // TTL. Symmetric with IOSStreamService.stopStream. Only the stream-owned

package/lib/src/device-managers/android/clipboardBroadcast.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIPBOARD_GET_ACTION = exports.CLIPBOARD_RECEIVER = void 0;
+exports.parseClipboardBroadcast = parseClipboardBroadcast;
+/** Appium Settings' clipboard receiver and its only clipboard action (read). */
+exports.CLIPBOARD_RECEIVER = 'io.appium.settings/.receivers.ClipboardReceiver';
+exports.CLIPBOARD_GET_ACTION = 'io.appium.settings.clipboard.get';
+/**
+ * The clipboard text from `am broadcast … io.appium.settings.clipboard.get`.
+ *
+ * Appium Settings answers `result=-1, data="<base64>"`, with an empty data for
+ * an empty clipboard. Anything else means the broadcast reached no receiver,
+ * or the wrong one (a missing app answers `result=0`), so it is an error, not
+ * an empty clipboard.
+ */
+function parseClipboardBroadcast(output) {
+    const answered = /\bresult=-1\b/.test(output);
+    const data = /data="([^"]*)"/.exec(output);
+    if (!answered || !data) {
+        const last = output.trim().split('\n').pop() || 'no output';
+        throw new Error(`Appium Settings didn’t return the clipboard. Check that it is installed and up to date (${last}).`);
+    }
+    return data[1] ? Buffer.from(data[1], 'base64').toString('utf8') : '';
+}

package/lib/src/device-managers/android/previewHold.js

@@ -0,0 +1,72 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mayReleasePreviewHold = mayReleasePreviewHold;
+exports.releaseIdlePreviewHold = releaseIdlePreviewHold;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const device_store_1 = require("../../data-service/device-store");
+const device_service_1 = require("../../data-service/device-service");
+const manualLock_1 = require("../../services/recording/manualLock");
+const recording_store_1 = require("../../services/recording/recording-store");
+/**
+ * Whether a live-preview hold can go: it is a preview hold (never an Appium
+ * session's lock), nobody watches over either transport, and no recording
+ * holds the device.
+ */
+function mayReleasePreviewHold(use) {
+    return ((0, manualLock_1.isManualLock)(use.sessionId) && !use.recording && use.h264Clients === 0 && use.mjpegViewers === 0);
+}
+/**
+ * Release a device's live-preview hold when a stream stops, unless something
+ * still uses the device. One hold covers both Android transports, so neither
+ * stream service may drop it while the other has viewers, and a recording
+ * holds the device the same way.
+ *
+ * The services are required here, when called, rather than imported: both of
+ * them call this, and importing them at the top would make the imports
+ * circular. They are looked up by class: TypeDI 0.10 ignores
+ * `@Service({ name })`, so a lookup by that name throws in the server.
+ */
+function releaseIdlePreviewHold(udid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        try {
+            const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+            if (!device)
+                return false;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const H264Service = require('./AndroidH264StreamService').default;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const MjpegService = require('./AndroidStreamService').default;
+            const h264 = typedi_1.Container.get(H264Service);
+            const mjpeg = typedi_1.Container.get(MjpegService);
+            const use = {
+                sessionId: device.session_id,
+                h264Clients: (_b = (_a = h264.getMultiplexer(udid)) === null || _a === void 0 ? void 0 : _a.clientCount) !== null && _b !== void 0 ? _b : 0,
+                mjpegViewers: (_d = (_c = mjpeg.getStreamStatus(udid)) === null || _c === void 0 ? void 0 : _c.viewerCount) !== null && _d !== void 0 ? _d : 0,
+                recording: yield typedi_1.Container.get(recording_store_1.RecordingStore).isRecording(udid),
+            };
+            if (!mayReleasePreviewHold(use))
+                return false;
+            yield (0, device_service_1.unblockDevice)(udid, device.host);
+            logger_1.default.info(`[${udid}] Released the live-preview hold: no viewers and no recording.`);
+            return true;
+        }
+        catch (e) {
+            logger_1.default.warn(`[${udid}] Could not check or release the live-preview hold: ${(_e = e === null || e === void 0 ? void 0 : e.message) !== null && _e !== void 0 ? _e : e}`);
+            return false;
+        }
+    });
+}

package/lib/src/device-managers/clipboardErrors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClipboardUnsupportedError = void 0;
+/**
+ * A clipboard operation this device can't do at all, as opposed to one that
+ * failed this time. The control route answers 501 for it: retrying won't help.
+ */
+class ClipboardUnsupportedError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'clipboard_unsupported';
+        this.name = 'ClipboardUnsupportedError';
+    }
+}
+exports.ClipboardUnsupportedError = ClipboardUnsupportedError;

package/lib/test/unit/android-clipboard.spec.js

@@ -0,0 +1,147 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const AndroidDeviceManager_1 = __importDefault(require("../../src/device-managers/AndroidDeviceManager"));
+const clipboardBroadcast_1 = require("../../src/device-managers/android/clipboardBroadcast");
+const clipboardErrors_1 = require("../../src/device-managers/clipboardErrors");
+/**
+ * Device control's clipboard on Android, measured 2026-09-26 on a Galaxy S9+
+ * (Android 10, Appium Settings 8.0.5):
+ *
+ * - Appium Settings can only *read* the clipboard. Its code holds one
+ *   clipboard action, io.appium.settings.clipboard.get. Our "set" broadcast
+ *   reached that same receiver, which read the clipboard, answered result=-1,
+ *   and the server reported success while nothing changed.
+ * - The read works, but only while Appium Settings is the default input
+ *   method (Android 10+ restricts clipboard reads to the IME). After an
+ *   on-device Copy of "xenonread" it returned data="eGVub25yZWFk".
+ * - Both methods swallowed every error, so the route always answered 200.
+ */
+const UDID = '381103b720057ece';
+const ORIGINAL_IME = 'com.samsung.android.honeyboard/.service.HoneyBoardService';
+const APPIUM_IME = 'io.appium.settings/.AppiumIME';
+function fakeAdb(broadcast) {
+    const calls = [];
+    const adbExec = sinon_1.default.stub().callsFake((args) => __awaiter(this, void 0, void 0, function* () {
+        calls.push(args);
+        const cmd = args.slice(2).join(' ');
+        if (cmd === 'shell settings get secure default_input_method')
+            return `${ORIGINAL_IME}\n`;
+        if (cmd.startsWith('shell am broadcast')) {
+            if (broadcast instanceof Error)
+                throw broadcast;
+            return broadcast;
+        }
+        return '';
+    }));
+    return { adbInstance: { adbExec }, calls };
+}
+function managerWith(adb) {
+    // The constructor starts device tracking; these tests need only the methods.
+    const manager = Object.create(AndroidDeviceManager_1.default.prototype);
+    manager.getAdb = () => __awaiter(this, void 0, void 0, function* () { return adb; });
+    return manager;
+}
+const imeSets = (calls) => calls.filter((c) => c.slice(2, 5).join(' ') === 'shell ime set').map((c) => c[5]);
+describe('Android clipboard', () => {
+    afterEach(() => sinon_1.default.restore());
+    describe('parseClipboardBroadcast', () => {
+        it('decodes the base64 text Appium Settings returns', () => {
+            (0, chai_1.expect)((0, clipboardBroadcast_1.parseClipboardBroadcast)('Broadcasting: Intent { … }\nBroadcast completed: result=-1, data="eGVub25yZWFk"')).to.equal('xenonread');
+        });
+        it('keeps non-ASCII text', () => {
+            const data = Buffer.from('héllo · 世界').toString('base64');
+            (0, chai_1.expect)((0, clipboardBroadcast_1.parseClipboardBroadcast)(`Broadcast completed: result=-1, data="${data}"`)).to.equal('héllo · 世界');
+        });
+        it('treats an empty answer as an empty clipboard', () => {
+            (0, chai_1.expect)((0, clipboardBroadcast_1.parseClipboardBroadcast)('Broadcast completed: result=-1, data=""')).to.equal('');
+        });
+        // A missing receiver answers result=0 with no data; that used to read as
+        // an empty clipboard.
+        it('refuses an answer that is not a clipboard', () => {
+            (0, chai_1.expect)(() => (0, clipboardBroadcast_1.parseClipboardBroadcast)('Broadcast completed: result=0')).to.throw(/Appium Settings didn’t return the clipboard/);
+            (0, chai_1.expect)(() => (0, clipboardBroadcast_1.parseClipboardBroadcast)('Broadcast completed: result=0, data="eA=="')).to.throw(/Appium Settings/);
+        });
+    });
+    describe('getClipboard', () => {
+        it('reads it with the documented broadcast, as the Appium IME', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const adb = fakeAdb('Broadcast completed: result=-1, data="eGVub25yZWFk"');
+            (0, chai_1.expect)(yield managerWith(adb).getClipboard(UDID)).to.equal('xenonread');
+            const broadcast = (_a = adb.calls.find((c) => c.includes('broadcast'))) !== null && _a !== void 0 ? _a : [];
+            (0, chai_1.expect)(broadcast).to.include.members([
+                '-n',
+                'io.appium.settings/.receivers.ClipboardReceiver',
+                '-a',
+                'io.appium.settings.clipboard.get',
+            ]);
+            (0, chai_1.expect)(imeSets(adb.calls)).to.deep.equal([APPIUM_IME, ORIGINAL_IME]);
+        }));
+        it('says why when Appium Settings does not answer, and restores the keyboard', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adb = fakeAdb('Broadcast completed: result=0');
+            let error;
+            try {
+                yield managerWith(adb).getClipboard(UDID);
+            }
+            catch (e) {
+                error = e;
+            }
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/Appium Settings didn’t return the clipboard/);
+            (0, chai_1.expect)(imeSets(adb.calls)).to.deep.equal([APPIUM_IME, ORIGINAL_IME]);
+        }));
+        it('does not swallow an adb failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adb = fakeAdb(new Error('device offline'));
+            let error;
+            try {
+                yield managerWith(adb).getClipboard(UDID);
+            }
+            catch (e) {
+                error = e;
+            }
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.equal('device offline');
+            (0, chai_1.expect)(imeSets(adb.calls)).to.deep.equal([APPIUM_IME, ORIGINAL_IME]);
+        }));
+        it('fails when adb is unavailable, instead of returning nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            let error;
+            try {
+                yield managerWith({ adbInstance: null }).getClipboard(UDID);
+            }
+            catch (e) {
+                error = e;
+            }
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.equal('ADB is not available');
+        }));
+    });
+    describe('setClipboard', () => {
+        it('refuses, since Appium Settings can only read the clipboard, and touches nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const adb = fakeAdb('Broadcast completed: result=-1, data=""');
+            let error;
+            try {
+                // Through the interface, as the control route calls it.
+                const manager = managerWith(adb);
+                yield ((_a = manager.setClipboard) === null || _a === void 0 ? void 0 : _a.call(manager, UDID, 'xenon-clip-test'));
+            }
+            catch (e) {
+                error = e;
+            }
+            (0, chai_1.expect)(error).to.be.instanceOf(clipboardErrors_1.ClipboardUnsupportedError);
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/can only read/);
+            (0, chai_1.expect)(adb.calls).to.deep.equal([]);
+        }));
+    });
+});