@basmilius/apple-devices 0.9.18 → 0.9.19

package/dist/index.d.mts

@@ -2,8 +2,8 @@
 import * as AirPlay from "@basmilius/apple-airplay";
 import { Proto, Protocol } from "@basmilius/apple-airplay";
 import { EventEmitter } from "node:events";
-import { AccessoryCredentials, AudioSource, DiscoveryResult, TimingServer } from "@basmilius/apple-common";
-import { AttentionState, ButtonPressType, HidCommandKey, LaunchableApp, MediaControlCommandKey, Protocol as Protocol$1, UserAccount } from "@basmilius/apple-companion-link";
+import { AccessoryCredentials, AudioSource, CommandError, DiscoveryResult, TimingServer } from "@basmilius/apple-common";
+import { AttentionState, ButtonPressType, HidCommandKey, LaunchableApp, MediaControlCommandKey, Protocol as Protocol$1, TextInputState, UserAccount } from "@basmilius/apple-companion-link";
 
 //#region src/airplay/player.d.ts
 declare class Player {
@@ -99,7 +99,7 @@ declare const STATE_SUBSCRIBE_SYMBOL: unique symbol;
 declare const STATE_UNSUBSCRIBE_SYMBOL: unique symbol;
 //#endregion
 //#region src/airplay/remote.d.ts
-declare class SendCommandError extends Error {
+declare class SendCommandError extends CommandError {
   readonly sendError: Proto.SendError_Enum;
   readonly handlerReturnStatus: Proto.HandlerReturnStatus_Enum;
   constructor(sendError: Proto.SendError_Enum, handlerReturnStatus: Proto.HandlerReturnStatus_Enum);
@@ -119,11 +119,15 @@ declare class export_default$1 {
   play(): Promise<void>;
   pause(): Promise<void>;
   playPause(): Promise<void>;
+  stop(): Promise<void>;
   next(): Promise<void>;
   previous(): Promise<void>;
   volumeUp(): Promise<void>;
   volumeDown(): Promise<void>;
   mute(): Promise<void>;
+  topMenu(): Promise<void>;
+  channelUp(): Promise<void>;
+  channelDown(): Promise<void>;
   commandPlay(): Promise<void>;
   commandPause(): Promise<void>;
   commandTogglePlayPause(): Promise<void>;
@@ -148,6 +152,10 @@ declare class export_default$1 {
   commandDislikeTrack(): Promise<void>;
   commandBookmarkTrack(): Promise<void>;
   commandAddNowPlayingItemToLibrary(): Promise<void>;
+  textSet(text: string): Promise<void>;
+  textAppend(text: string): Promise<void>;
+  textClear(): Promise<void>;
+  getKeyboardSession(): Promise<void>;
   tap(x: number, y: number, finger?: number): Promise<void>;
   swipeUp(duration?: number): Promise<void>;
   swipeDown(duration?: number): Promise<void>;
@@ -163,6 +171,7 @@ type EventMap$4 = {
   readonly clients: [Record<string, Client>];
   readonly deviceInfo: [Proto.DeviceInfoMessage];
   readonly deviceInfoUpdate: [Proto.DeviceInfoMessage];
+  readonly keyboard: [Proto.KeyboardMessage];
   readonly nowPlayingChanged: [client: Client | null, player: Player | null];
   readonly originClientProperties: [Proto.OriginClientPropertiesMessage];
   readonly playerClientProperties: [Proto.PlayerClientPropertiesMessage];
@@ -186,9 +195,15 @@ type EventMap$4 = {
 declare class export_default$2 extends EventEmitter<EventMap$4> {
   #private;
   get clients(): Record<string, Client>;
+  get isKeyboardActive(): boolean;
+  get keyboardAttributes(): Proto.TextEditingAttributes | null;
+  get keyboardState(): Proto.KeyboardState_Enum;
   get nowPlayingClient(): Client | null;
   get outputDeviceUID(): string | null;
   get outputDevices(): Proto.AVOutputDeviceDescriptor[];
+  get clusterID(): string | null;
+  get clusterType(): number;
+  get isClusterAware(): boolean;
   get volume(): number;
   get volumeAvailable(): boolean;
   get volumeCapabilities(): Proto.VolumeCapabilities_Enum;
@@ -196,6 +211,7 @@ declare class export_default$2 extends EventEmitter<EventMap$4> {
   [STATE_SUBSCRIBE_SYMBOL](): void;
   [STATE_UNSUBSCRIBE_SYMBOL](): void;
   clear(): void;
+  onKeyboard(message: Proto.KeyboardMessage): void;
   onDeviceInfo(message: Proto.DeviceInfoMessage): void;
   onDeviceInfoUpdate(message: Proto.DeviceInfoMessage): void;
   onOriginClientProperties(message: Proto.OriginClientPropertiesMessage): void;
@@ -251,6 +267,9 @@ declare class export_default extends EventEmitter<EventMap$3> {
   addOutputDevices(deviceUIDs: string[]): Promise<void>;
   removeOutputDevices(deviceUIDs: string[]): Promise<void>;
   setOutputDevices(deviceUIDs: string[]): Promise<void>;
+  playUrl(url: string, position?: number): Promise<void>;
+  waitForPlaybackEnd(): Promise<void>;
+  stopPlayUrl(): void;
   streamAudio(source: AudioSource): Promise<void>;
   requestPlaybackQueue(length: number): Promise<void>;
   sendCommand(command: Proto.Command, options?: Proto.CommandOptions): Promise<void>;
@@ -265,6 +284,7 @@ type EventMap$2 = {
   connected: [];
   disconnected: [unexpected: boolean];
   power: [AttentionState];
+  textInput: [TextInputState];
 };
 declare class export_default$5 extends EventEmitter<EventMap$2> {
   #private;
@@ -272,6 +292,7 @@ declare class export_default$5 extends EventEmitter<EventMap$2> {
   get discoveryResult(): DiscoveryResult;
   set discoveryResult(discoveryResult: DiscoveryResult);
   get isConnected(): boolean;
+  get textInputState(): TextInputState;
   constructor(discoveryResult: DiscoveryResult);
   connect(): Promise<void>;
   disconnect(): Promise<void>;
@@ -285,6 +306,9 @@ declare class export_default$5 extends EventEmitter<EventMap$2> {
   mediaControlCommand(command: MediaControlCommandKey, content?: object): Promise<void>;
   pressButton(command: HidCommandKey, type?: ButtonPressType, holdDelayMs?: number): Promise<void>;
   switchUserAccount(accountId: string): Promise<void>;
+  textSet(text: string): Promise<void>;
+  textAppend(text: string): Promise<void>;
+  textClear(): Promise<void>;
   onSystemStatus(data: {
     readonly state: number;
   }): Promise<void>;
@@ -298,6 +322,7 @@ type EventMap$1 = {
   connected: [];
   disconnected: [unexpected: boolean];
   power: [AttentionState];
+  textInput: [TextInputState];
 };
 declare class export_default$4 extends EventEmitter<EventMap$1> {
   #private;
@@ -338,6 +363,9 @@ declare class export_default$4 extends EventEmitter<EventMap$1> {
   getUserAccounts(): Promise<UserAccount[]>;
   launchApp(bundleId: string): Promise<void>;
   switchUserAccount(accountId: string): Promise<void>;
+  textSet(text: string): Promise<void>;
+  textAppend(text: string): Promise<void>;
+  textClear(): Promise<void>;
   getCommandInfo(command: AirPlay.Proto.Command): Promise<AirPlay.Proto.CommandInfo | null>;
   isCommandSupported(command: AirPlay.Proto.Command): Promise<boolean>;
 }
@@ -375,6 +403,9 @@ declare abstract class export_default$8 extends EventEmitter<EventMap> {
   stop(): Promise<void>;
   next(): Promise<void>;
   previous(): Promise<void>;
+  playUrl(url: string, position?: number): Promise<void>;
+  waitForPlaybackEnd(): Promise<void>;
+  stopPlayUrl(): void;
   streamAudio(source: AudioSource): Promise<void>;
   getCommandInfo(command: AirPlay.Proto.Command): Promise<AirPlay.Proto.CommandInfo | null>;
   isCommandSupported(command: AirPlay.Proto.Command): Promise<boolean>;

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import * as AirPlay from "@basmilius/apple-airplay";
 import { DataStreamMessage, Proto, Protocol } from "@basmilius/apple-airplay";
 import { EventEmitter } from "node:events";
-import { waitFor } from "@basmilius/apple-common";
+import { CommandError, CredentialsError, waitFor } from "@basmilius/apple-common";
 import { Protocol as Protocol$1, convertAttentionState } from "@basmilius/apple-companion-link";
+import { Plist } from "@basmilius/apple-encoding";
 
 //#region src/airplay/player.ts
 const COCOA_EPOCH_OFFSET = 978307200;
@@ -334,7 +335,7 @@ const STATE_UNSUBSCRIBE_SYMBOL = Symbol("com.basmilius.airplay:unsubscribe");
 
 //#endregion
 //#region src/airplay/remote.ts
-var SendCommandError = class extends Error {
+var SendCommandError = class extends CommandError {
 	sendError;
 	handlerReturnStatus;
 	constructor(sendError, handlerReturnStatus) {
@@ -392,6 +393,9 @@ var remote_default = class {
 		if (this.#device.state.nowPlayingClient?.isPlaying) await this.pause();
 		else await this.play();
 	}
+	async stop() {
+		await this.pressAndRelease(12, 183);
+	}
 	async next() {
 		await this.pressAndRelease(12, 181);
 	}
@@ -407,6 +411,15 @@ var remote_default = class {
 	async mute() {
 		await this.pressAndRelease(12, 226);
 	}
+	async topMenu() {
+		await this.pressAndRelease(12, 96);
+	}
+	async channelUp() {
+		await this.pressAndRelease(12, 156);
+	}
+	async channelDown() {
+		await this.pressAndRelease(12, 157);
+	}
 	async commandPlay() {
 		await this.#sendCommand(Proto.Command.Play);
 	}
@@ -479,6 +492,18 @@ var remote_default = class {
 	async commandAddNowPlayingItemToLibrary() {
 		await this.#sendCommand(Proto.Command.AddNowPlayingItemToLibrary);
 	}
+	async textSet(text) {
+		await this.#dataStream.send(DataStreamMessage.textInput(text, Proto.ActionType_Enum.Set));
+	}
+	async textAppend(text) {
+		await this.#dataStream.send(DataStreamMessage.textInput(text, Proto.ActionType_Enum.Insert));
+	}
+	async textClear() {
+		await this.#dataStream.send(DataStreamMessage.textInput("", Proto.ActionType_Enum.ClearAction));
+	}
+	async getKeyboardSession() {
+		await this.#dataStream.send(DataStreamMessage.getKeyboardSession());
+	}
 	async tap(x, y, finger = 1) {
 		await this.#sendTouch(x, y, 1, finger);
 		await waitFor(50);
@@ -554,6 +579,15 @@ var state_default = class extends EventEmitter {
 	get clients() {
 		return this.#clients;
 	}
+	get isKeyboardActive() {
+		return this.#keyboardState === Proto.KeyboardState_Enum.DidBeginEditing || this.#keyboardState === Proto.KeyboardState_Enum.Editing || this.#keyboardState === Proto.KeyboardState_Enum.TextDidChange;
+	}
+	get keyboardAttributes() {
+		return this.#keyboardAttributes;
+	}
+	get keyboardState() {
+		return this.#keyboardState;
+	}
 	get nowPlayingClient() {
 		return this.#nowPlayingClientBundleIdentifier ? this.#clients[this.#nowPlayingClientBundleIdentifier] ?? null : null;
 	}
@@ -563,6 +597,15 @@ var state_default = class extends EventEmitter {
 	get outputDevices() {
 		return this.#outputDevices;
 	}
+	get clusterID() {
+		return this.#clusterID;
+	}
+	get clusterType() {
+		return this.#clusterType;
+	}
+	get isClusterAware() {
+		return this.#isClusterAware;
+	}
 	get volume() {
 		return this.#volume;
 	}
@@ -574,10 +617,15 @@ var state_default = class extends EventEmitter {
 	}
 	#device;
 	#clients;
+	#keyboardAttributes;
+	#keyboardState;
 	#nowPlayingClientBundleIdentifier;
 	#nowPlayingSnapshot;
 	#outputDeviceUID;
 	#outputDevices = [];
+	#clusterID;
+	#clusterType;
+	#isClusterAware;
 	#volume;
 	#volumeAvailable;
 	#volumeCapabilities;
@@ -585,6 +633,7 @@ var state_default = class extends EventEmitter {
 		super();
 		this.#device = device;
 		this.clear();
+		this.onKeyboard = this.onKeyboard.bind(this);
 		this.onDeviceInfo = this.onDeviceInfo.bind(this);
 		this.onDeviceInfoUpdate = this.onDeviceInfoUpdate.bind(this);
 		this.onOriginClientProperties = this.onOriginClientProperties.bind(this);
@@ -607,6 +656,7 @@ var state_default = class extends EventEmitter {
 		this.onVolumeDidChange = this.onVolumeDidChange.bind(this);
 	}
 	[STATE_SUBSCRIBE_SYMBOL]() {
+		this.#dataStream.on("keyboard", this.onKeyboard);
 		this.#dataStream.on("deviceInfo", this.onDeviceInfo);
 		this.#dataStream.on("deviceInfoUpdate", this.onDeviceInfoUpdate);
 		this.#dataStream.on("originClientProperties", this.onOriginClientProperties);
@@ -631,6 +681,7 @@ var state_default = class extends EventEmitter {
 	[STATE_UNSUBSCRIBE_SYMBOL]() {
 		const dataStream = this.#dataStream;
 		if (!dataStream) return;
+		dataStream.off("keyboard", this.onKeyboard);
 		dataStream.off("deviceInfo", this.onDeviceInfo);
 		dataStream.off("deviceInfoUpdate", this.onDeviceInfoUpdate);
 		dataStream.off("originClientProperties", this.onOriginClientProperties);
@@ -654,14 +705,24 @@ var state_default = class extends EventEmitter {
 	}
 	clear() {
 		this.#clients = {};
+		this.#keyboardAttributes = null;
+		this.#keyboardState = Proto.KeyboardState_Enum.Unknown;
 		this.#nowPlayingClientBundleIdentifier = null;
 		this.#nowPlayingSnapshot = null;
 		this.#outputDeviceUID = null;
 		this.#outputDevices = [];
+		this.#clusterID = null;
+		this.#clusterType = 0;
+		this.#isClusterAware = false;
 		this.#volume = 0;
 		this.#volumeAvailable = false;
 		this.#volumeCapabilities = Proto.VolumeCapabilities_Enum.None;
 	}
+	onKeyboard(message) {
+		this.#keyboardState = message.state;
+		this.#keyboardAttributes = message.attributes ?? null;
+		this.emit("keyboard", message);
+	}
 	onDeviceInfo(message) {
 		this.#updateOutputDeviceUID(message);
 		this.emit("deviceInfo", message);
@@ -751,7 +812,7 @@ var state_default = class extends EventEmitter {
 		this.emit("clients", this.#clients);
 	}
 	onUpdateOutputDevice(message) {
-		this.#outputDevices = message.outputDevices;
+		this.#outputDevices = message.clusterAwareOutputDevices?.length > 0 ? message.clusterAwareOutputDevices : message.outputDevices;
 		this.emit("updateOutputDevice", message);
 	}
 	onVolumeControlAvailability(message) {
@@ -770,6 +831,9 @@ var state_default = class extends EventEmitter {
 	}
 	#updateOutputDeviceUID(message) {
 		this.#outputDeviceUID = message.clusterID || message.deviceUID || message.uniqueIdentifier || null;
+		this.#clusterID = message.clusterID || null;
+		this.#clusterType = message.clusterType ?? 0;
+		this.#isClusterAware = message.isClusterAware ?? false;
 	}
 	#client(bundleIdentifier, displayName) {
 		if (bundleIdentifier in this.#clients) {
@@ -844,31 +908,31 @@ var volume_default = class {
 			case Proto.VolumeCapabilities_Enum.Relative:
 				await this.#device.remote.volumeDown();
 				break;
-			default: throw new Error("Volume control is not available.");
+			default: throw new CommandError("Volume control is not available.");
 		}
 	}
 	async up() {
 		switch (this.#state.volumeCapabilities) {
 			case Proto.VolumeCapabilities_Enum.Absolute:
 			case Proto.VolumeCapabilities_Enum.Both:
-				const newVolume = Math.max(0, this.#state.volume + VOLUME_STEP);
+				const newVolume = Math.min(1, Math.max(0, this.#state.volume + VOLUME_STEP));
 				await this.set(newVolume);
 				break;
 			case Proto.VolumeCapabilities_Enum.Relative:
 				await this.#device.remote.volumeUp();
 				break;
-			default: throw new Error("Volume control is not available.");
+			default: throw new CommandError("Volume control is not available.");
 		}
 	}
 	async get() {
-		if (!this.#state.outputDeviceUID) throw new Error("No output device active.");
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
 		const response = await this.#protocol.dataStream.exchange(DataStreamMessage.getVolume(this.#state.outputDeviceUID));
 		if (response.type === Proto.ProtocolMessage_Type.GET_VOLUME_RESULT_MESSAGE) return DataStreamMessage.getExtension(response, Proto.getVolumeResultMessage).volume;
-		throw new Error("Failed to get volume.");
+		throw new CommandError("Failed to get volume.");
 	}
 	async set(volume) {
-		if (!this.#state.outputDeviceUID) throw new Error("No output device active.");
-		if (![Proto.VolumeCapabilities_Enum.Absolute, Proto.VolumeCapabilities_Enum.Both].includes(this.#state.volumeCapabilities)) throw new Error("Absolute volume control is not available.");
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		if (![Proto.VolumeCapabilities_Enum.Absolute, Proto.VolumeCapabilities_Enum.Both].includes(this.#state.volumeCapabilities)) throw new CommandError("Absolute volume control is not available.");
 		volume = Math.min(1, Math.max(0, volume));
 		this.#protocol.context.logger.info(`Setting volume to ${volume} for device ${this.#state.outputDeviceUID}`);
 		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolume(this.#state.outputDeviceUID, volume));
@@ -905,6 +969,9 @@ var device_default = class extends EventEmitter {
 	set timingServer(timingServer) {
 		this.#timingServer = timingServer;
 	}
+	#boundOnClose = () => this.#onClose();
+	#boundOnError = (err) => this.#onError(err);
+	#boundOnTimeout = () => this.#onTimeout();
 	#remote;
 	#state;
 	#volume;
@@ -913,6 +980,9 @@ var device_default = class extends EventEmitter {
 	#discoveryResult;
 	#feedbackInterval;
 	#keys;
+	#playUrlProtocol;
+	#prevDataStream;
+	#prevEventStream;
 	#protocol;
 	#timingServer;
 	constructor(discoveryResult) {
@@ -923,12 +993,17 @@ var device_default = class extends EventEmitter {
 		this.#volume = new volume_default(this);
 	}
 	async connect() {
+		if (this.#protocol) {
+			this.#protocol.controlStream.off("close", this.#boundOnClose);
+			this.#protocol.controlStream.off("error", this.#boundOnError);
+			this.#protocol.controlStream.off("timeout", this.#boundOnTimeout);
+		}
 		this.#disconnect = false;
 		this.#state.clear();
 		this.#protocol = new Protocol(this.#discoveryResult);
-		this.#protocol.controlStream.on("close", this.#onClose.bind(this));
-		this.#protocol.controlStream.on("error", this.#onError.bind(this));
-		this.#protocol.controlStream.on("timeout", this.#onTimeout.bind(this));
+		this.#protocol.controlStream.on("close", this.#boundOnClose);
+		this.#protocol.controlStream.on("error", this.#boundOnError);
+		this.#protocol.controlStream.on("timeout", this.#boundOnTimeout);
 		await this.#protocol.connect();
 		if (this.#credentials) this.#keys = await this.#protocol.verify.start(this.#credentials);
 		else {
@@ -944,6 +1019,7 @@ var device_default = class extends EventEmitter {
 			clearInterval(this.#feedbackInterval);
 			this.#feedbackInterval = void 0;
 		}
+		this.#cleanupPlayUrl();
 		this.#unsubscribe();
 		this.#protocol.disconnect();
 	}
@@ -963,6 +1039,40 @@ var device_default = class extends EventEmitter {
 	async setOutputDevices(deviceUIDs) {
 		await this.#protocol.dataStream.exchange(DataStreamMessage.modifyOutputContext([], [], deviceUIDs));
 	}
+	async playUrl(url, position = 0) {
+		if (!this.#keys) throw new Error("Not connected. Call connect() first.");
+		this.#playUrlProtocol?.disconnect();
+		const playProtocol = new Protocol(this.#discoveryResult);
+		if (this.#timingServer) playProtocol.useTimingServer(this.#timingServer);
+		await playProtocol.connect();
+		let keys;
+		if (this.#credentials) keys = await playProtocol.verify.start(this.#credentials);
+		else {
+			await playProtocol.pairing.start();
+			keys = await playProtocol.pairing.transient();
+		}
+		playProtocol.controlStream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+		this.#playUrlProtocol = playProtocol;
+		await playProtocol.playUrl(url, keys.sharedSecret, keys.pairingId, position);
+	}
+	async waitForPlaybackEnd() {
+		if (!this.#playUrlProtocol) return;
+		try {
+			await this.#playUrlProtocol.waitForPlaybackEnd();
+		} finally {
+			this.#cleanupPlayUrl();
+		}
+	}
+	stopPlayUrl() {
+		this.#cleanupPlayUrl();
+	}
+	#cleanupPlayUrl() {
+		if (this.#playUrlProtocol) {
+			this.#playUrlProtocol.stopPlayUrl();
+			this.#playUrlProtocol.disconnect();
+			this.#playUrlProtocol = void 0;
+		}
+	}
 	async streamAudio(source) {
 		await this.#protocol.setupAudioStream(source);
 	}
@@ -1002,17 +1112,23 @@ var device_default = class extends EventEmitter {
 		this.#unsubscribe();
 		if (this.#timingServer) this.#protocol.useTimingServer(this.#timingServer);
 		try {
+			this.#prevDataStream?.off("error", this.#boundOnError);
+			this.#prevDataStream?.off("timeout", this.#boundOnTimeout);
+			this.#prevEventStream?.off("error", this.#boundOnError);
+			this.#prevEventStream?.off("timeout", this.#boundOnTimeout);
 			await this.#protocol.setupEventStream(keys.sharedSecret, keys.pairingId);
 			await this.#protocol.setupDataStream(keys.sharedSecret, () => this.#subscribe());
-			this.#protocol.dataStream.on("error", this.#onError.bind(this));
-			this.#protocol.dataStream.on("timeout", this.#onTimeout.bind(this));
-			this.#protocol.eventStream.on("error", this.#onError.bind(this));
-			this.#protocol.eventStream.on("timeout", this.#onTimeout.bind(this));
+			this.#protocol.dataStream.on("error", this.#boundOnError);
+			this.#protocol.dataStream.on("timeout", this.#boundOnTimeout);
+			this.#protocol.eventStream.on("error", this.#boundOnError);
+			this.#protocol.eventStream.on("timeout", this.#boundOnTimeout);
+			this.#prevDataStream = this.#protocol.dataStream;
+			this.#prevEventStream = this.#protocol.eventStream;
 			if (this.#feedbackInterval) clearInterval(this.#feedbackInterval);
 			this.#feedbackInterval = setInterval(async () => await this.#feedback(), FEEDBACK_INTERVAL);
 			await this.#protocol.dataStream.exchange(DataStreamMessage.deviceInfo(keys.pairingId));
 			await this.#protocol.dataStream.exchange(DataStreamMessage.setConnectionState());
-			await this.#protocol.dataStream.exchange(DataStreamMessage.clientUpdatesConfig());
+			await this.#protocol.dataStream.exchange(DataStreamMessage.clientUpdatesConfig(true, true, true, true, true, true));
 			this.#protocol.context.logger.info("Protocol ready.");
 		} catch (err) {
 			if (this.#feedbackInterval) {
@@ -1061,6 +1177,23 @@ var device_default$1 = class extends EventEmitter {
 	#heartbeatInterval;
 	#keys;
 	#protocol;
+	get textInputState() {
+		return this.#textInputState;
+	}
+	#boundOnClose = async () => this.#onClose();
+	#boundOnError = async (err) => this.#onError(err);
+	#boundOnTimeout = async () => this.#onTimeout();
+	#onMediaControl = (data) => {
+		this.emit("mediaControl", data);
+	};
+	#textInputState = {
+		isActive: false,
+		documentText: "",
+		isSecure: false,
+		keyboardType: 0,
+		autocorrection: false,
+		autocapitalization: false
+	};
 	constructor(discoveryResult) {
 		super();
 		this.#discoveryResult = discoveryResult;
@@ -1068,12 +1201,17 @@ var device_default$1 = class extends EventEmitter {
 		this.onTVSystemStatus = this.onTVSystemStatus.bind(this);
 	}
 	async connect() {
-		if (!this.#credentials) throw new Error("Credentials are required to connect to a Companion Link device.");
+		if (!this.#credentials) throw new CredentialsError("Credentials are required to connect to a Companion Link device.");
+		if (this.#protocol) {
+			this.#protocol.stream.off("close", this.#boundOnClose);
+			this.#protocol.stream.off("error", this.#boundOnError);
+			this.#protocol.stream.off("timeout", this.#boundOnTimeout);
+		}
 		this.#disconnect = false;
 		this.#protocol = new Protocol$1(this.#discoveryResult);
-		this.#protocol.stream.on("close", async () => this.#onClose());
-		this.#protocol.stream.on("error", async (err) => this.#onError(err));
-		this.#protocol.stream.on("timeout", async () => this.#onTimeout());
+		this.#protocol.stream.on("close", this.#boundOnClose);
+		this.#protocol.stream.on("error", this.#boundOnError);
+		this.#protocol.stream.on("timeout", this.#boundOnTimeout);
 		await this.#protocol.connect();
 		this.#keys = await this.#protocol.verify.start(this.#credentials);
 		await this.#setup();
@@ -1120,6 +1258,15 @@ var device_default$1 = class extends EventEmitter {
 	async switchUserAccount(accountId) {
 		await this.#protocol.switchUserAccount(accountId);
 	}
+	async textSet(text) {
+		await this.#protocol.textInputCommand(text, true);
+	}
+	async textAppend(text) {
+		await this.#protocol.textInputCommand(text, false);
+	}
+	async textClear() {
+		await this.#protocol.textInputCommand("", true);
+	}
 	async #heartbeat() {
 		try {
 			this.#protocol.noOp();
@@ -1150,10 +1297,11 @@ var device_default$1 = class extends EventEmitter {
 			await this.#protocol.tvrcSessionStart();
 			await this.#protocol.touchStart();
 			await this.#protocol.tiStart();
-			await this.#protocol.subscribe("_iMC", (data) => {
-				this.emit("mediaControl", data);
-			});
-			this.#heartbeatInterval = setInterval(async () => await this.#heartbeat(), 15e3);
+			this.#heartbeatInterval = setInterval(() => {
+				this.#heartbeat().catch((err) => {
+					this.#protocol.context.logger.error("Heartbeat failed", err);
+				});
+			}, 15e3);
 			await this.#subscribe();
 		} catch (err) {
 			clearInterval(this.#heartbeatInterval);
@@ -1162,17 +1310,73 @@ var device_default$1 = class extends EventEmitter {
 		}
 	}
 	async #subscribe() {
-		await this.#protocol.subscribe("SystemStatus", this.onSystemStatus);
-		await this.#protocol.subscribe("TVSystemStatus", this.onTVSystemStatus);
+		this.#protocol.stream.on("_iMC", this.#onMediaControl);
+		this.#protocol.stream.on("SystemStatus", this.onSystemStatus);
+		this.#protocol.stream.on("TVSystemStatus", this.onTVSystemStatus);
+		this.#protocol.stream.on("_tiStarted", this.#onTextInputStarted);
+		this.#protocol.stream.on("_tiStopped", this.#onTextInputStopped);
+		this.#protocol.registerInterests([
+			"_iMC",
+			"SystemStatus",
+			"TVSystemStatus"
+		]);
 		const state = await this.getAttentionState();
 		this.emit("power", state);
 	}
 	async #unsubscribe() {
+		this.#protocol.stream.off("_iMC", this.#onMediaControl);
+		this.#protocol.stream.off("SystemStatus", this.onSystemStatus);
+		this.#protocol.stream.off("TVSystemStatus", this.onTVSystemStatus);
+		this.#protocol.stream.off("_tiStarted", this.#onTextInputStarted);
+		this.#protocol.stream.off("_tiStopped", this.#onTextInputStopped);
 		try {
-			await this.#protocol.unsubscribe("SystemStatus", this.onSystemStatus);
-			await this.#protocol.unsubscribe("TVSystemStatus", this.onTVSystemStatus);
+			this.#protocol.deregisterInterests([
+				"_iMC",
+				"SystemStatus",
+				"TVSystemStatus"
+			]);
 		} catch (_) {}
 	}
+	#onTextInputStarted = async (data) => {
+		try {
+			const payload = data;
+			let documentText = "";
+			let isSecure = false;
+			let keyboardType = 0;
+			let autocorrection = false;
+			let autocapitalization = false;
+			if (payload?._tiD) {
+				const plistData = Plist.parse(Buffer.from(payload._tiD).buffer);
+				documentText = plistData._tiDT ?? "";
+				isSecure = plistData._tiSR ?? false;
+				keyboardType = plistData._tiKT ?? 0;
+				autocorrection = plistData._tiAC ?? false;
+				autocapitalization = plistData._tiAP ?? false;
+			}
+			this.#textInputState = {
+				isActive: true,
+				documentText,
+				isSecure,
+				keyboardType,
+				autocorrection,
+				autocapitalization
+			};
+			this.emit("textInput", this.#textInputState);
+		} catch (err) {
+			this.#protocol.context.logger.error("Text input started parse error", err);
+		}
+	};
+	#onTextInputStopped = async (_data) => {
+		this.#textInputState = {
+			isActive: false,
+			documentText: "",
+			isSecure: false,
+			keyboardType: 0,
+			autocorrection: false,
+			autocapitalization: false
+		};
+		this.emit("textInput", this.#textInputState);
+	};
 	async onSystemStatus(data) {
 		this.#protocol.context.logger.info("System Status", data);
 		this.emit("power", convertAttentionState(data.state));
@@ -1255,12 +1459,18 @@ var apple_tv_default = class extends EventEmitter {
 		this.#companionLink.on("connected", () => this.#onConnected());
 		this.#companionLink.on("disconnected", (unexpected) => this.#onDisconnected(unexpected));
 		this.#companionLink.on("power", (state) => this.emit("power", state));
+		this.#companionLink.on("textInput", (state) => this.emit("textInput", state));
 	}
 	async connect(airplayCredentials, companionLinkCredentials) {
 		this.#airplay.setCredentials(airplayCredentials);
 		await this.#companionLink.setCredentials(companionLinkCredentials ?? airplayCredentials);
 		await this.#airplay.connect();
-		await this.#companionLink.connect();
+		try {
+			await this.#companionLink.connect();
+		} catch (err) {
+			this.#airplay.disconnectSafely();
+			throw err;
+		}
 		this.#disconnect = false;
 	}
 	async disconnect() {
@@ -1315,6 +1525,15 @@ var apple_tv_default = class extends EventEmitter {
 	async switchUserAccount(accountId) {
 		await this.#companionLink.switchUserAccount(accountId);
 	}
+	async textSet(text) {
+		await this.#companionLink.textSet(text);
+	}
+	async textAppend(text) {
+		await this.#companionLink.textAppend(text);
+	}
+	async textClear() {
+		await this.#companionLink.textClear();
+	}
 	async getCommandInfo(command) {
 		const client = this.#airplay.state.nowPlayingClient;
 		if (!client) return null;
@@ -1427,6 +1646,15 @@ var homepod_base_default = class extends EventEmitter {
 	async previous() {
 		await this.#airplay.sendCommand(AirPlay.Proto.Command.PreviousInContext);
 	}
+	async playUrl(url, position = 0) {
+		await this.#airplay.playUrl(url, position);
+	}
+	async waitForPlaybackEnd() {
+		await this.#airplay.waitForPlaybackEnd();
+	}
+	stopPlayUrl() {
+		this.#airplay.stopPlayUrl();
+	}
 	async streamAudio(source) {
 		await this.#airplay.streamAudio(source);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-devices",
     "description": "Exposes various Apple devices to connect with either AirPlay or Companion Link.",
-    "version": "0.9.18",
+    "version": "0.9.19",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -49,10 +49,10 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-airplay": "0.9.18",
-        "@basmilius/apple-common": "0.9.18",
-        "@basmilius/apple-companion-link": "0.9.18",
-        "@basmilius/apple-encoding": "0.9.18"
+        "@basmilius/apple-airplay": "0.9.19",
+        "@basmilius/apple-common": "0.9.19",
+        "@basmilius/apple-companion-link": "0.9.19",
+        "@basmilius/apple-encoding": "0.9.19"
     },
     "devDependencies": {
         "@types/bun": "^1.3.11",