hap-nodejs/dist/lib/controller/RemoteController.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SiriAudioSession = exports.SiriAudioSessionEvents = exports.RemoteController = exports.RemoteControllerEvents = exports.TargetUpdates = exports.AudioCodecTypes = exports.ButtonState = exports.TargetCategory = exports.ButtonType = void 0;
const tslib_1 = require("tslib");
const assert_1 = tslib_1.__importDefault(require("assert"));
const debug_1 = tslib_1.__importDefault(require("debug"));
const events_1 = require("events");
const Characteristic_1 = require("../Characteristic");
const datastream_1 = require("../datastream");
const Service_1 = require("../Service");
const tlv = tslib_1.__importStar(require("../util/tlv"));
const debug = (0, debug_1.default)("HAP-NodeJS:Remote:Controller");
var TargetControlCommands;
(function (TargetControlCommands) {
    TargetControlCommands[TargetControlCommands["MAXIMUM_TARGETS"] = 1] = "MAXIMUM_TARGETS";
    TargetControlCommands[TargetControlCommands["TICKS_PER_SECOND"] = 2] = "TICKS_PER_SECOND";
    TargetControlCommands[TargetControlCommands["SUPPORTED_BUTTON_CONFIGURATION"] = 3] = "SUPPORTED_BUTTON_CONFIGURATION";
    TargetControlCommands[TargetControlCommands["TYPE"] = 4] = "TYPE";
})(TargetControlCommands || (TargetControlCommands = {}));
var SupportedButtonConfigurationTypes;
(function (SupportedButtonConfigurationTypes) {
    SupportedButtonConfigurationTypes[SupportedButtonConfigurationTypes["BUTTON_ID"] = 1] = "BUTTON_ID";
    SupportedButtonConfigurationTypes[SupportedButtonConfigurationTypes["BUTTON_TYPE"] = 2] = "BUTTON_TYPE";
})(SupportedButtonConfigurationTypes || (SupportedButtonConfigurationTypes = {}));
/**
 * @group Apple TV Remote
 */
var ButtonType;
(function (ButtonType) {
    // noinspection JSUnusedGlobalSymbols
    ButtonType[ButtonType["UNDEFINED"] = 0] = "UNDEFINED";
    ButtonType[ButtonType["MENU"] = 1] = "MENU";
    ButtonType[ButtonType["PLAY_PAUSE"] = 2] = "PLAY_PAUSE";
    ButtonType[ButtonType["TV_HOME"] = 3] = "TV_HOME";
    ButtonType[ButtonType["SELECT"] = 4] = "SELECT";
    ButtonType[ButtonType["ARROW_UP"] = 5] = "ARROW_UP";
    ButtonType[ButtonType["ARROW_RIGHT"] = 6] = "ARROW_RIGHT";
    ButtonType[ButtonType["ARROW_DOWN"] = 7] = "ARROW_DOWN";
    ButtonType[ButtonType["ARROW_LEFT"] = 8] = "ARROW_LEFT";
    ButtonType[ButtonType["VOLUME_UP"] = 9] = "VOLUME_UP";
    ButtonType[ButtonType["VOLUME_DOWN"] = 10] = "VOLUME_DOWN";
    ButtonType[ButtonType["SIRI"] = 11] = "SIRI";
    ButtonType[ButtonType["POWER"] = 12] = "POWER";
    ButtonType[ButtonType["GENERIC"] = 13] = "GENERIC";
})(ButtonType || (exports.ButtonType = ButtonType = {}));
var TargetControlList;
(function (TargetControlList) {
    TargetControlList[TargetControlList["OPERATION"] = 1] = "OPERATION";
    TargetControlList[TargetControlList["TARGET_CONFIGURATION"] = 2] = "TARGET_CONFIGURATION";
})(TargetControlList || (TargetControlList = {}));
var Operation;
(function (Operation) {
    // noinspection JSUnusedGlobalSymbols
    Operation[Operation["UNDEFINED"] = 0] = "UNDEFINED";
    Operation[Operation["LIST"] = 1] = "LIST";
    Operation[Operation["ADD"] = 2] = "ADD";
    Operation[Operation["REMOVE"] = 3] = "REMOVE";
    Operation[Operation["RESET"] = 4] = "RESET";
    Operation[Operation["UPDATE"] = 5] = "UPDATE";
})(Operation || (Operation = {}));
var TargetConfigurationTypes;
(function (TargetConfigurationTypes) {
    TargetConfigurationTypes[TargetConfigurationTypes["TARGET_IDENTIFIER"] = 1] = "TARGET_IDENTIFIER";
    TargetConfigurationTypes[TargetConfigurationTypes["TARGET_NAME"] = 2] = "TARGET_NAME";
    TargetConfigurationTypes[TargetConfigurationTypes["TARGET_CATEGORY"] = 3] = "TARGET_CATEGORY";
    TargetConfigurationTypes[TargetConfigurationTypes["BUTTON_CONFIGURATION"] = 4] = "BUTTON_CONFIGURATION";
})(TargetConfigurationTypes || (TargetConfigurationTypes = {}));
/**
 * @group Apple TV Remote
 */
var TargetCategory;
(function (TargetCategory) {
    // noinspection JSUnusedGlobalSymbols
    TargetCategory[TargetCategory["UNDEFINED"] = 0] = "UNDEFINED";
    TargetCategory[TargetCategory["APPLE_TV"] = 24] = "APPLE_TV";
})(TargetCategory || (exports.TargetCategory = TargetCategory = {}));
var ButtonConfigurationTypes;
(function (ButtonConfigurationTypes) {
    ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_ID"] = 1] = "BUTTON_ID";
    ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_TYPE"] = 2] = "BUTTON_TYPE";
    ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_NAME"] = 3] = "BUTTON_NAME";
})(ButtonConfigurationTypes || (ButtonConfigurationTypes = {}));
var ButtonEvent;
(function (ButtonEvent) {
    ButtonEvent[ButtonEvent["BUTTON_ID"] = 1] = "BUTTON_ID";
    ButtonEvent[ButtonEvent["BUTTON_STATE"] = 2] = "BUTTON_STATE";
    ButtonEvent[ButtonEvent["TIMESTAMP"] = 3] = "TIMESTAMP";
    ButtonEvent[ButtonEvent["ACTIVE_IDENTIFIER"] = 4] = "ACTIVE_IDENTIFIER";
})(ButtonEvent || (ButtonEvent = {}));
/**
 * @group Apple TV Remote
 */
var ButtonState;
(function (ButtonState) {
    ButtonState[ButtonState["UP"] = 0] = "UP";
    ButtonState[ButtonState["DOWN"] = 1] = "DOWN";
})(ButtonState || (exports.ButtonState = ButtonState = {}));
var SelectedAudioInputStreamConfigurationTypes;
(function (SelectedAudioInputStreamConfigurationTypes) {
    SelectedAudioInputStreamConfigurationTypes[SelectedAudioInputStreamConfigurationTypes["SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION"] = 1] = "SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION";
})(SelectedAudioInputStreamConfigurationTypes || (SelectedAudioInputStreamConfigurationTypes = {}));
// ----------
var SupportedAudioStreamConfigurationTypes;
(function (SupportedAudioStreamConfigurationTypes) {
    // noinspection JSUnusedGlobalSymbols
    SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["AUDIO_CODEC_CONFIGURATION"] = 1] = "AUDIO_CODEC_CONFIGURATION";
    SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["COMFORT_NOISE_SUPPORT"] = 2] = "COMFORT_NOISE_SUPPORT";
})(SupportedAudioStreamConfigurationTypes || (SupportedAudioStreamConfigurationTypes = {}));
var AudioCodecConfigurationTypes;
(function (AudioCodecConfigurationTypes) {
    AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
    AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_PARAMETERS"] = 2] = "CODEC_PARAMETERS";
})(AudioCodecConfigurationTypes || (AudioCodecConfigurationTypes = {}));
/**
 * @group Camera
 */
var AudioCodecTypes;
(function (AudioCodecTypes) {
    // noinspection JSUnusedGlobalSymbols
    AudioCodecTypes[AudioCodecTypes["PCMU"] = 0] = "PCMU";
    AudioCodecTypes[AudioCodecTypes["PCMA"] = 1] = "PCMA";
    AudioCodecTypes[AudioCodecTypes["AAC_ELD"] = 2] = "AAC_ELD";
    AudioCodecTypes[AudioCodecTypes["OPUS"] = 3] = "OPUS";
    AudioCodecTypes[AudioCodecTypes["MSBC"] = 4] = "MSBC";
    AudioCodecTypes[AudioCodecTypes["AMR"] = 5] = "AMR";
    AudioCodecTypes[AudioCodecTypes["AMR_WB"] = 6] = "AMR_WB";
})(AudioCodecTypes || (exports.AudioCodecTypes = AudioCodecTypes = {}));
var AudioCodecParametersTypes;
(function (AudioCodecParametersTypes) {
    AudioCodecParametersTypes[AudioCodecParametersTypes["CHANNEL"] = 1] = "CHANNEL";
    AudioCodecParametersTypes[AudioCodecParametersTypes["BIT_RATE"] = 2] = "BIT_RATE";
    AudioCodecParametersTypes[AudioCodecParametersTypes["SAMPLE_RATE"] = 3] = "SAMPLE_RATE";
    AudioCodecParametersTypes[AudioCodecParametersTypes["PACKET_TIME"] = 4] = "PACKET_TIME"; // only present in selected audio codec parameters tlv
})(AudioCodecParametersTypes || (AudioCodecParametersTypes = {}));
var SiriAudioSessionState;
(function (SiriAudioSessionState) {
    SiriAudioSessionState[SiriAudioSessionState["STARTING"] = 0] = "STARTING";
    SiriAudioSessionState[SiriAudioSessionState["SENDING"] = 1] = "SENDING";
    SiriAudioSessionState[SiriAudioSessionState["CLOSING"] = 2] = "CLOSING";
    SiriAudioSessionState[SiriAudioSessionState["CLOSED"] = 3] = "CLOSED";
})(SiriAudioSessionState || (SiriAudioSessionState = {}));
/**
 * @group Apple TV Remote
 */
var TargetUpdates;
(function (TargetUpdates) {
    TargetUpdates[TargetUpdates["NAME"] = 0] = "NAME";
    TargetUpdates[TargetUpdates["CATEGORY"] = 1] = "CATEGORY";
    TargetUpdates[TargetUpdates["UPDATED_BUTTONS"] = 2] = "UPDATED_BUTTONS";
    TargetUpdates[TargetUpdates["REMOVED_BUTTONS"] = 3] = "REMOVED_BUTTONS";
})(TargetUpdates || (exports.TargetUpdates = TargetUpdates = {}));
/**
 * @group Apple TV Remote
 */
var RemoteControllerEvents;
(function (RemoteControllerEvents) {
    /**
     * This event is emitted when the active state of the remote has changed.
     * active = true indicates that there is currently an Apple TV listening of button presses and audio streams.
     */
    RemoteControllerEvents["ACTIVE_CHANGE"] = "active-change";
    /**
     * This event is emitted when the currently selected target has changed.
     * Possible reasons for a changed active identifier: manual change via api call, first target configuration
     * gets added, active target gets removed, accessory gets unpaired, reset request was sent.
     * An activeIdentifier of 0 indicates that no target is selected.
     */
    RemoteControllerEvents["ACTIVE_IDENTIFIER_CHANGE"] = "active-identifier-change";
    /**
     * This event is emitted when a new target configuration is received. As we currently do not persistently store
     * configured targets, this will be called at every startup for every Apple TV configured in the home.
     */
    RemoteControllerEvents["TARGET_ADDED"] = "target-add";
    /**
     * This event is emitted when an existing target was updated.
     * The 'updates' array indicates what exactly was changed for the target.
     */
    RemoteControllerEvents["TARGET_UPDATED"] = "target-update";
    /**
     * This event is emitted when an existing configuration for a target was removed.
     */
    RemoteControllerEvents["TARGET_REMOVED"] = "target-remove";
    /**
     * This event is emitted when a reset of the target configuration is requested.
     * With this event every configuration made should be reset. This event is also called
     * when the accessory gets unpaired.
     */
    RemoteControllerEvents["TARGETS_RESET"] = "targets-reset";
})(RemoteControllerEvents || (exports.RemoteControllerEvents = RemoteControllerEvents = {}));
/**
 * Handles everything needed to implement a fully working HomeKit remote controller.
 *
 * @group Apple TV Remote
 */
// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
class RemoteController extends events_1.EventEmitter {
    stateChangeDelegate;
    audioSupported;
    audioProducerConstructor;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    audioProducerOptions;
    targetControlManagementService;
    targetControlService;
    siriService;
    audioStreamManagementService;
    dataStreamManagement;
    buttons = {}; // internal mapping of buttonId to buttonType for supported buttons
    supportedConfiguration;
    targetConfigurations = new Map();
    targetConfigurationsString = "";
    lastButtonEvent = "";
    activeIdentifier = 0; // id of 0 means no device selected
    activeConnection; // session which marked this remote as active and listens for events and siri
    activeConnectionDisconnectListener;
    supportedAudioConfiguration;
    selectedAudioConfiguration;
    selectedAudioConfigurationString;
    dataStreamConnections = new Map(); // maps targetIdentifiers to active data stream connections
    activeAudioSession;
    nextAudioSession;
    /**
     * @private
     */
    eventHandler;
    /**
     * @private
     */
    requestHandler;
    /**
     * Creates a new RemoteController.
     * If siri voice input is supported the constructor to an SiriAudioStreamProducer needs to be supplied.
     * Otherwise, a remote without voice support will be created.
     *
     * For every audio session a new SiriAudioStreamProducer will be constructed.
     *
     * @param audioProducerConstructor - constructor for a SiriAudioStreamProducer
     * @param producerOptions - if supplied this argument will be supplied as third argument of the SiriAudioStreamProducer
     *                          constructor. This should be used to supply configurations to the stream producer.
     */
    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
    constructor(audioProducerConstructor, producerOptions) {
        super();
        this.audioSupported = audioProducerConstructor !== undefined;
        this.audioProducerConstructor = audioProducerConstructor;
        this.audioProducerOptions = producerOptions;
        const configuration = this.constructSupportedConfiguration();
        this.supportedConfiguration = this.buildTargetControlSupportedConfigurationTLV(configuration);
        const audioConfiguration = this.constructSupportedAudioConfiguration();
        this.supportedAudioConfiguration = RemoteController.buildSupportedAudioConfigurationTLV(audioConfiguration);
        this.selectedAudioConfiguration = {
            codecType: 3 /* AudioCodecTypes.OPUS */,
            parameters: {
                channels: 1,
                bitrate: 0 /* AudioBitrate.VARIABLE */,
                samplerate: 1 /* AudioSamplerate.KHZ_16 */,
                rtpTime: 20,
            },
        };
        this.selectedAudioConfigurationString = RemoteController.buildSelectedAudioConfigurationTLV({
            audioCodecConfiguration: this.selectedAudioConfiguration,
        });
    }
    /**
     * @private
     */
    controllerId() {
        return "remote" /* DefaultControllerType.REMOTE */;
    }
    /**
     * Set a new target as active target. A value of 0 indicates that no target is selected currently.
     *
     * @param activeIdentifier - target identifier
     */
    setActiveIdentifier(activeIdentifier) {
        if (activeIdentifier === this.activeIdentifier) {
            return;
        }
        if (activeIdentifier !== 0 && !this.targetConfigurations.has(activeIdentifier)) {
            throw Error("Tried setting unconfigured targetIdentifier to active");
        }
        debug("%d is now the active target", activeIdentifier);
        this.activeIdentifier = activeIdentifier;
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier).updateValue(activeIdentifier);
        if (this.activeAudioSession) {
            this.handleSiriAudioStop();
        }
        setTimeout(() => this.emit("active-identifier-change" /* RemoteControllerEvents.ACTIVE_IDENTIFIER_CHANGE */, activeIdentifier), 0);
        this.setInactive();
    }
    /**
     * @returns if the current target is active, meaning the active device is listening for button events or audio sessions
     */
    isActive() {
        return !!this.activeConnection;
    }
    /**
     * Checks if the supplied targetIdentifier is configured.
     *
     * @param targetIdentifier - The target identifier.
     */
    isConfigured(targetIdentifier) {
        return this.targetConfigurations.has(targetIdentifier);
    }
    /**
     * Returns the targetIdentifier for a give device name
     *
     * @param name - The name of the device.
     * @returns The targetIdentifier of the device or undefined if not existent.
     */
    getTargetIdentifierByName(name) {
        for (const [activeIdentifier, configuration] of Object.entries(this.targetConfigurations)) {
            if (configuration.targetName === name) {
                return parseInt(activeIdentifier, 10);
            }
        }
        return undefined;
    }
    /**
     * Sends a button event to press the supplied button.
     *
     * @param button - button to be pressed
     */
    pushButton(button) {
        this.sendButtonEvent(button, 1 /* ButtonState.DOWN */);
    }
    /**
     * Sends a button event that the supplied button was released.
     *
     * @param button - button which was released
     */
    releaseButton(button) {
        this.sendButtonEvent(button, 0 /* ButtonState.UP */);
    }
    /**
     * Presses a supplied button for a given time.
     *
     * @param button - button to be pressed and released
     * @param time - time in milliseconds (defaults to 200ms)
     */
    pushAndReleaseButton(button, time = 200) {
        this.pushButton(button);
        setTimeout(() => this.releaseButton(button), time);
    }
    // ---------------------------------- CONFIGURATION ----------------------------------
    // override methods if you would like to change anything (but should not be necessary most likely)
    constructSupportedConfiguration() {
        const configuration = {
            maximumTargets: 10, // some random number. (ten should be okay?)
            ticksPerSecond: 1000, // we rely on unix timestamps
            supportedButtonConfiguration: [],
            hardwareImplemented: this.audioSupported, // siri is only allowed for hardware implemented remotes
        };
        const supportedButtons = [
            1 /* ButtonType.MENU */, 2 /* ButtonType.PLAY_PAUSE */, 3 /* ButtonType.TV_HOME */, 4 /* ButtonType.SELECT */,
            5 /* ButtonType.ARROW_UP */, 6 /* ButtonType.ARROW_RIGHT */, 7 /* ButtonType.ARROW_DOWN */, 8 /* ButtonType.ARROW_LEFT */,
            9 /* ButtonType.VOLUME_UP */, 10 /* ButtonType.VOLUME_DOWN */, 12 /* ButtonType.POWER */, 13 /* ButtonType.GENERIC */,
        ];
        if (this.audioSupported) { // add siri button if this remote supports it
            supportedButtons.push(11 /* ButtonType.SIRI */);
        }
        supportedButtons.forEach(button => {
            const buttonConfiguration = {
                buttonID: 100 + button,
                buttonType: button,
            };
            configuration.supportedButtonConfiguration.push(buttonConfiguration);
            this.buttons[button] = buttonConfiguration.buttonID; // also saving mapping of type to id locally
        });
        return configuration;
    }
    constructSupportedAudioConfiguration() {
        // the following parameters are expected from HomeKit for a remote
        return {
            audioCodecConfiguration: {
                codecType: 3 /* AudioCodecTypes.OPUS */,
                parameters: {
                    channels: 1,
                    bitrate: 0 /* AudioBitrate.VARIABLE */,
                    samplerate: 1 /* AudioSamplerate.KHZ_16 */,
                },
            },
        };
    }
    // --------------------------------- TARGET CONTROL ----------------------------------
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    handleTargetControlWrite(value, callback) {
        const data = Buffer.from(value, "base64");
        const objects = tlv.decode(data);
        const operation = objects[1 /* TargetControlList.OPERATION */][0];
        let targetConfiguration = undefined;
        if (objects[2 /* TargetControlList.TARGET_CONFIGURATION */]) { // if target configuration was sent, parse it
            targetConfiguration = this.parseTargetConfigurationTLV(objects[2 /* TargetControlList.TARGET_CONFIGURATION */]);
        }
        debug("Received TargetControl write operation %s", Operation[operation]);
        let handler;
        switch (operation) {
            case Operation.ADD:
                handler = this.handleAddTarget.bind(this);
                break;
            case Operation.UPDATE:
                handler = this.handleUpdateTarget.bind(this);
                break;
            case Operation.REMOVE:
                handler = this.handleRemoveTarget.bind(this);
                break;
            case Operation.RESET:
                handler = this.handleResetTargets.bind(this);
                break;
            case Operation.LIST:
                handler = this.handleListTargets.bind(this);
                break;
            default:
                callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */, undefined);
                return;
        }
        const status = handler(targetConfiguration);
        if (status === 0 /* HAPStatus.SUCCESS */) {
            callback(undefined, this.targetConfigurationsString); // passing value for write response
            if (operation === Operation.ADD && this.activeIdentifier === 0) {
                this.setActiveIdentifier(targetConfiguration.targetIdentifier);
            }
        }
        else {
            callback(new Error(status + ""));
        }
    }
    handleAddTarget(targetConfiguration) {
        if (!targetConfiguration) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        this.targetConfigurations.set(targetConfiguration.targetIdentifier, targetConfiguration);
        debug("Configured new target '" + targetConfiguration.targetName + "' with targetIdentifier '" + targetConfiguration.targetIdentifier + "'");
        setTimeout(() => this.emit("target-add" /* RemoteControllerEvents.TARGET_ADDED */, targetConfiguration), 0);
        this.updatedTargetConfiguration(); // set response
        return 0 /* HAPStatus.SUCCESS */;
    }
    handleUpdateTarget(targetConfiguration) {
        if (!targetConfiguration) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        const updates = [];
        const configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
        if (!configuredTarget) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        if (targetConfiguration.targetName) {
            debug("Target name was updated '%s' => '%s' (%d)", configuredTarget.targetName, targetConfiguration.targetName, configuredTarget.targetIdentifier);
            configuredTarget.targetName = targetConfiguration.targetName;
            updates.push(0 /* TargetUpdates.NAME */);
        }
        if (targetConfiguration.targetCategory) {
            debug("Target category was updated '%d' => '%d' for target '%s' (%d)", configuredTarget.targetCategory, targetConfiguration.targetCategory, configuredTarget.targetName, configuredTarget.targetIdentifier);
            configuredTarget.targetCategory = targetConfiguration.targetCategory;
            updates.push(1 /* TargetUpdates.CATEGORY */);
        }
        if (targetConfiguration.buttonConfiguration) {
            debug("%d button configurations were updated for target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
            for (const configuration of Object.values(targetConfiguration.buttonConfiguration)) {
                const savedConfiguration = configuredTarget.buttonConfiguration[configuration.buttonID];
                savedConfiguration.buttonType = configuration.buttonType;
                savedConfiguration.buttonName = configuration.buttonName;
            }
            updates.push(2 /* TargetUpdates.UPDATED_BUTTONS */);
        }
        setTimeout(() => this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, targetConfiguration, updates), 0);
        this.updatedTargetConfiguration(); // set response
        return 0 /* HAPStatus.SUCCESS */;
    }
    handleRemoveTarget(targetConfiguration) {
        if (!targetConfiguration) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        const configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
        if (!configuredTarget) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        if (targetConfiguration.buttonConfiguration) {
            for (const key in targetConfiguration.buttonConfiguration) {
                if (Object.prototype.hasOwnProperty.call(targetConfiguration.buttonConfiguration, key)) {
                    delete configuredTarget.buttonConfiguration[key];
                }
            }
            debug("Removed %d button configurations of target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
            setTimeout(() => this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, configuredTarget, [3 /* TargetUpdates.REMOVED_BUTTONS */]), 0);
        }
        else {
            this.targetConfigurations.delete(targetConfiguration.targetIdentifier);
            debug("Target '%s' (%d) was removed", configuredTarget.targetName, configuredTarget.targetIdentifier);
            setTimeout(() => this.emit("target-remove" /* RemoteControllerEvents.TARGET_REMOVED */, targetConfiguration.targetIdentifier), 0);
            const keys = Object.keys(this.targetConfigurations);
            this.setActiveIdentifier(keys.length === 0 ? 0 : parseInt(keys[0], 10)); // switch to next available remote
        }
        this.updatedTargetConfiguration(); // set response
        return 0 /* HAPStatus.SUCCESS */;
    }
    handleResetTargets(targetConfiguration) {
        if (targetConfiguration) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        debug("Resetting all target configurations");
        this.targetConfigurations = new Map();
        this.updatedTargetConfiguration(); // set response
        setTimeout(() => this.emit("targets-reset" /* RemoteControllerEvents.TARGETS_RESET */), 0);
        this.setActiveIdentifier(0); // resetting active identifier (also sets active to false)
        return 0 /* HAPStatus.SUCCESS */;
    }
    handleListTargets(targetConfiguration) {
        if (targetConfiguration) {
            return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
        }
        // this.targetConfigurationsString is updated after each change, so we basically don't need to do anything here
        debug("Returning " + Object.keys(this.targetConfigurations).length + " target configurations");
        return 0 /* HAPStatus.SUCCESS */;
    }
    handleActiveWrite(value, callback, connection) {
        if (this.activeIdentifier === 0) {
            debug("Tried to change active state. There is no active target set though");
            callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
            return;
        }
        if (this.activeConnection) {
            this.activeConnection.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionDisconnectListener);
            this.activeConnection = undefined;
            this.activeConnectionDisconnectListener = undefined;
        }
        this.activeConnection = value ? connection : undefined;
        if (this.activeConnection) { // register listener when hap connection disconnects
            this.activeConnectionDisconnectListener = this.handleActiveSessionDisconnected.bind(this, this.activeConnection);
            this.activeConnection.on("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionDisconnectListener);
        }
        const activeTarget = this.targetConfigurations.get(this.activeIdentifier);
        if (!activeTarget) {
            callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
            return;
        }
        debug("Remote with activeTarget '%s' (%d) was set to %s", activeTarget.targetName, this.activeIdentifier, value ? "ACTIVE" : "INACTIVE");
        callback();
        this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, value);
    }
    setInactive() {
        if (this.activeConnection === undefined) {
            return;
        }
        this.activeConnection.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionDisconnectListener);
        this.activeConnection = undefined;
        this.activeConnectionDisconnectListener = undefined;
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active).updateValue(false);
        debug("Remote was set to INACTIVE");
        setTimeout(() => this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, false), 0);
    }
    handleActiveSessionDisconnected(connection) {
        if (connection !== this.activeConnection) {
            return;
        }
        debug("Active hap session disconnected!");
        this.setInactive();
    }
    sendButtonEvent(button, buttonState) {
        const buttonID = this.buttons[button];
        if (buttonID === undefined || buttonID === 0) {
            throw new Error("Tried sending button event for unsupported button (" + button + ")");
        }
        if (this.activeIdentifier === 0) { // cannot press button if no device is selected
            throw new Error("Tried sending button event although no target was selected");
        }
        if (!this.isActive()) { // cannot press button if device is not active (aka no Apple TV is listening)
            throw new Error("Tried sending button event although target was not marked as active");
        }
        if (button === 11 /* ButtonType.SIRI */ && this.audioSupported) {
            if (buttonState === 1 /* ButtonState.DOWN */) { // start streaming session
                this.handleSiriAudioStart();
            }
            else if (buttonState === 0 /* ButtonState.UP */) { // stop streaming session
                this.handleSiriAudioStop();
            }
            return;
        }
        const buttonIdTlv = tlv.encode(1 /* ButtonEvent.BUTTON_ID */, buttonID);
        const buttonStateTlv = tlv.encode(2 /* ButtonEvent.BUTTON_STATE */, buttonState);
        const timestampTlv = tlv.encode(3 /* ButtonEvent.TIMESTAMP */, tlv.writeVariableUIntLE(new Date().getTime()));
        const activeIdentifierTlv = tlv.encode(4 /* ButtonEvent.ACTIVE_IDENTIFIER */, tlv.writeUInt32(this.activeIdentifier));
        this.lastButtonEvent = Buffer.concat([
            buttonIdTlv, buttonStateTlv, timestampTlv, activeIdentifierTlv,
        ]).toString("base64");
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent).sendEventNotification(this.lastButtonEvent);
    }
    parseTargetConfigurationTLV(data) {
        const configTLV = tlv.decode(data);
        const identifier = tlv.readUInt32(configTLV[1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */]);
        let name = undefined;
        if (configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */]) {
            name = configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */].toString();
        }
        let category = undefined;
        if (configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]) {
            category = tlv.readUInt16(configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]);
        }
        const buttonConfiguration = {};
        if (configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */]) {
            const buttonConfigurationTLV = tlv.decodeList(configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */], 1 /* ButtonConfigurationTypes.BUTTON_ID */);
            buttonConfigurationTLV.forEach(entry => {
                const buttonId = entry[1 /* ButtonConfigurationTypes.BUTTON_ID */][0];
                const buttonType = tlv.readUInt16(entry[2 /* ButtonConfigurationTypes.BUTTON_TYPE */]);
                let buttonName;
                if (entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */]) {
                    buttonName = entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */].toString();
                }
                else {
                    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
                    buttonName = ButtonType[buttonType];
                }
                buttonConfiguration[buttonId] = {
                    buttonID: buttonId,
                    buttonType: buttonType,
                    buttonName: buttonName,
                };
            });
        }
        return {
            targetIdentifier: identifier,
            targetName: name,
            targetCategory: category,
            buttonConfiguration: buttonConfiguration,
        };
    }
    updatedTargetConfiguration() {
        const bufferList = [];
        for (const configuration of Object.values(this.targetConfigurations)) {
            const targetIdentifier = tlv.encode(1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */, tlv.writeUInt32(configuration.targetIdentifier));
            const targetName = tlv.encode(2 /* TargetConfigurationTypes.TARGET_NAME */, configuration.targetName);
            const targetCategory = tlv.encode(3 /* TargetConfigurationTypes.TARGET_CATEGORY */, tlv.writeUInt16(configuration.targetCategory));
            const buttonConfigurationBuffers = [];
            for (const value of configuration.buttonConfiguration.values()) {
                let tlvBuffer = tlv.encode(1 /* ButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* ButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
                if (value.buttonName) {
                    tlvBuffer = Buffer.concat([
                        tlvBuffer,
                        tlv.encode(3 /* ButtonConfigurationTypes.BUTTON_NAME */, value.buttonName),
                    ]);
                }
                buttonConfigurationBuffers.push(tlvBuffer);
            }
            const buttonConfiguration = tlv.encode(4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */, Buffer.concat(buttonConfigurationBuffers));
            const targetConfiguration = Buffer.concat([targetIdentifier, targetName, targetCategory, buttonConfiguration]);
            bufferList.push(tlv.encode(2 /* TargetControlList.TARGET_CONFIGURATION */, targetConfiguration));
        }
        this.targetConfigurationsString = Buffer.concat(bufferList).toString("base64");
        this.stateChangeDelegate?.();
    }
    buildTargetControlSupportedConfigurationTLV(configuration) {
        const maximumTargets = tlv.encode(1 /* TargetControlCommands.MAXIMUM_TARGETS */, configuration.maximumTargets);
        const ticksPerSecond = tlv.encode(2 /* TargetControlCommands.TICKS_PER_SECOND */, tlv.writeVariableUIntLE(configuration.ticksPerSecond));
        const supportedButtonConfigurationBuffers = [];
        configuration.supportedButtonConfiguration.forEach(value => {
            const tlvBuffer = tlv.encode(1 /* SupportedButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* SupportedButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
            supportedButtonConfigurationBuffers.push(tlvBuffer);
        });
        const supportedButtonConfiguration = tlv.encode(3 /* TargetControlCommands.SUPPORTED_BUTTON_CONFIGURATION */, Buffer.concat(supportedButtonConfigurationBuffers));
        const type = tlv.encode(4 /* TargetControlCommands.TYPE */, configuration.hardwareImplemented ? 1 : 0);
        return Buffer.concat([maximumTargets, ticksPerSecond, supportedButtonConfiguration, type]).toString("base64");
    }
    // --------------------------------- SIRI/DATA STREAM --------------------------------
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    handleTargetControlWhoAmI(connection, message) {
        const targetIdentifier = message.identifier;
        this.dataStreamConnections.set(targetIdentifier, connection);
        debug("Discovered HDS connection for targetIdentifier %s", targetIdentifier);
        connection.addProtocolHandler("dataSend" /* Protocols.DATA_SEND */, this);
    }
    handleSiriAudioStart() {
        if (!this.audioSupported) {
            throw new Error("Cannot start siri stream on remote where siri is not supported");
        }
        if (!this.isActive()) {
            debug("Tried opening Siri audio stream, however no controller is connected!");
            return;
        }
        if (this.activeAudioSession && (!this.activeAudioSession.isClosing() || this.nextAudioSession)) {
            // there is already a session running, which is not in closing state and/or there is even already a
            // nextAudioSession running. ignoring start request
            debug("Tried opening Siri audio stream, however there is already one in progress");
            return;
        }
        const connection = this.dataStreamConnections.get(this.activeIdentifier); // get connection for current target
        if (connection === undefined) { // target seems not connected, ignore it
            debug("Tried opening Siri audio stream however target is not connected via HDS");
            return;
        }
        // eslint-disable-next-line @typescript-eslint/no-use-before-define
        const audioSession = new SiriAudioSession(connection, this.selectedAudioConfiguration, this.audioProducerConstructor, this.audioProducerOptions);
        if (!this.activeAudioSession) {
            this.activeAudioSession = audioSession;
        }
        else {
            // we checked above that this only happens if the activeAudioSession is in closing state,
            // so no collision with the input device can happen
            this.nextAudioSession = audioSession;
        }
        audioSession.on("close" /* SiriAudioSessionEvents.CLOSE */, this.handleSiriAudioSessionClosed.bind(this, audioSession));
        audioSession.start();
    }
    handleSiriAudioStop() {
        if (this.activeAudioSession) {
            if (!this.activeAudioSession.isClosing()) {
                this.activeAudioSession.stop();
                return;
            }
            else if (this.nextAudioSession && !this.nextAudioSession.isClosing()) {
                this.nextAudioSession.stop();
                return;
            }
        }
        debug("handleSiriAudioStop called although no audio session was started");
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    handleDataSendAckEvent(message) {
        const streamId = message.streamId;
        const endOfStream = message.endOfStream;
        if (this.activeAudioSession && this.activeAudioSession.streamId === streamId) {
            this.activeAudioSession.handleDataSendAckEvent(endOfStream);
        }
        else if (this.nextAudioSession && this.nextAudioSession.streamId === streamId) {
            this.nextAudioSession.handleDataSendAckEvent(endOfStream);
        }
        else {
            debug("Received dataSend acknowledgment event for unknown streamId '%s'", streamId);
        }
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    handleDataSendCloseEvent(message) {
        const streamId = message.streamId;
        const reason = message.reason;
        if (this.activeAudioSession && this.activeAudioSession.streamId === streamId) {
            this.activeAudioSession.handleDataSendCloseEvent(reason);
        }
        else if (this.nextAudioSession && this.nextAudioSession.streamId === streamId) {
            this.nextAudioSession.handleDataSendCloseEvent(reason);
        }
        else {
            debug("Received dataSend close event for unknown streamId '%s'", streamId);
        }
    }
    handleSiriAudioSessionClosed(session) {
        if (session === this.activeAudioSession) {
            this.activeAudioSession = this.nextAudioSession;
            this.nextAudioSession = undefined;
        }
        else if (session === this.nextAudioSession) {
            this.nextAudioSession = undefined;
        }
    }
    handleDataStreamConnectionClosed(connection) {
        for (const [targetIdentifier, connection0] of this.dataStreamConnections) {
            if (connection === connection0) {
                debug("HDS connection disconnected for targetIdentifier %s", targetIdentifier);
                this.dataStreamConnections.delete(targetIdentifier);
                break;
            }
        }
    }
    // ------------------------------- AUDIO CONFIGURATION -------------------------------
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    handleSelectedAudioConfigurationWrite(value, callback) {
        const data = Buffer.from(value, "base64");
        const objects = tlv.decode(data);
        const selectedAudioStreamConfiguration = tlv.decode(objects[1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */]);
        const codec = selectedAudioStreamConfiguration[1 /* AudioCodecConfigurationTypes.CODEC_TYPE */][0];
        const parameters = tlv.decode(selectedAudioStreamConfiguration[2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */]);
        const channels = parameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
        const bitrate = parameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
        const samplerate = parameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
        this.selectedAudioConfiguration = {
            codecType: codec,
            parameters: {
                channels: channels,
                bitrate: bitrate,
                samplerate: samplerate,
                rtpTime: 20,
            },
        };
        this.selectedAudioConfigurationString = RemoteController.buildSelectedAudioConfigurationTLV({
            audioCodecConfiguration: this.selectedAudioConfiguration,
        });
        callback();
    }
    static buildSupportedAudioConfigurationTLV(configuration) {
        const codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
        const supportedAudioStreamConfiguration = tlv.encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurationTLV);
        return supportedAudioStreamConfiguration.toString("base64");
    }
    static buildSelectedAudioConfigurationTLV(configuration) {
        const codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
        const supportedAudioStreamConfiguration = tlv.encode(1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */, codecConfigurationTLV);
        return supportedAudioStreamConfiguration.toString("base64");
    }
    static buildCodecConfigurationTLV(codecConfiguration) {
        const parameters = codecConfiguration.parameters;
        let parametersTLV = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, parameters.channels, 2 /* AudioCodecParametersTypes.BIT_RATE */, parameters.bitrate, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, parameters.samplerate);
        if (parameters.rtpTime) {
            parametersTLV = Buffer.concat([
                parametersTLV,
                tlv.encode(4 /* AudioCodecParametersTypes.PACKET_TIME */, parameters.rtpTime),
            ]);
        }
        return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codecConfiguration.codecType, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, parametersTLV);
    }
    // -----------------------------------------------------------------------------------
    /**
     * @private
     */
    constructServices() {
        this.targetControlManagementService = new Service_1.Service.TargetControlManagement("", "");
        this.targetControlManagementService.setCharacteristic(Characteristic_1.Characteristic.TargetControlSupportedConfiguration, this.supportedConfiguration);
        this.targetControlManagementService.setCharacteristic(Characteristic_1.Characteristic.TargetControlList, this.targetConfigurationsString);
        this.targetControlManagementService.setPrimaryService();
        // you can also expose multiple TargetControl services to control multiple apple tvs simultaneously.
        // should we extend this class to support multiple TargetControl services or should users just create a second accessory?
        this.targetControlService = new Service_1.Service.TargetControl("", "");
        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier, 0);
        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.Active, false);
        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.ButtonEvent, this.lastButtonEvent);
        if (this.audioSupported) {
            this.siriService = new Service_1.Service.Siri("", "");
            this.siriService.setCharacteristic(Characteristic_1.Characteristic.SiriInputType, Characteristic_1.Characteristic.SiriInputType.PUSH_BUTTON_TRIGGERED_APPLE_TV);
            this.audioStreamManagementService = new Service_1.Service.AudioStreamManagement("", "");
            this.audioStreamManagementService.setCharacteristic(Characteristic_1.Characteristic.SupportedAudioStreamConfiguration, this.supportedAudioConfiguration);
            this.audioStreamManagementService.setCharacteristic(Characteristic_1.Characteristic.SelectedAudioStreamConfiguration, this.selectedAudioConfigurationString);
            this.dataStreamManagement = new datastream_1.DataStreamManagement();
            this.siriService.addLinkedService(this.dataStreamManagement.getService());
            this.siriService.addLinkedService(this.audioStreamManagementService);
        }
        return {
            targetControlManagement: this.targetControlManagementService,
            targetControl: this.targetControlService,
            siri: this.siriService,
            audioStreamManagement: this.audioStreamManagementService,
            dataStreamTransportManagement: this.dataStreamManagement?.getService(),
        };
    }
    /**
     * @private
     */
    initWithServices(serviceMap) {
        this.targetControlManagementService = serviceMap.targetControlManagement;
        this.targetControlService = serviceMap.targetControl;
        this.siriService = serviceMap.siri;
        this.audioStreamManagementService = serviceMap.audioStreamManagement;
        this.dataStreamManagement = new datastream_1.DataStreamManagement(serviceMap.dataStreamTransportManagement);
    }
    /**
     * @private
     */
    configureServices() {
        if (!this.targetControlManagementService || !this.targetControlService) {
            throw new Error("Unexpected state: Services not configured!"); // playing it save
        }
        this.targetControlManagementService.getCharacteristic(Characteristic_1.Characteristic.TargetControlList)
            .on("get" /* CharacteristicEventTypes.GET */, callback => {
            callback(null, this.targetConfigurationsString);
        })
            .on("set" /* CharacteristicEventTypes.SET */, this.handleTargetControlWrite.bind(this));
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier)
            .on("get" /* CharacteristicEventTypes.GET */, callback => {
            callback(undefined, this.activeIdentifier);
        });
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active)
            .on("get" /* CharacteristicEventTypes.GET */, callback => {
            callback(undefined, this.isActive());
        })
            .on("set" /* CharacteristicEventTypes.SET */, (value, callback, context, connection) => {
            if (!connection) {
                debug("Set event handler for Remote.Active cannot be called from plugin. Connection undefined!");
                callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                return;
            }
            this.handleActiveWrite(value, callback, connection);
        });
        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent)
            .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
            callback(undefined, this.lastButtonEvent);
        });
        if (this.audioSupported) {
            this.audioStreamManagementService.getCharacteristic(Characteristic_1.Characteristic.SelectedAudioStreamConfiguration)
                .on("get" /* CharacteristicEventTypes.GET */, callback => {
                callback(null, this.selectedAudioConfigurationString);
            })
                .on("set" /* CharacteristicEventTypes.SET */, this.handleSelectedAudioConfigurationWrite.bind(this))
                .updateValue(this.selectedAudioConfigurationString);
            this.dataStreamManagement
                .onEventMessage("targetControl" /* Protocols.TARGET_CONTROL */, "whoami" /* Topics.WHOAMI */, this.handleTargetControlWhoAmI.bind(this))
                .onServerEvent("connection-closed" /* DataStreamServerEvent.CONNECTION_CLOSED */, this.handleDataStreamConnectionClosed.bind(this));
            this.eventHandler = {
                ["ack" /* Topics.ACK */]: this.handleDataSendAckEvent.bind(this),
                ["close" /* Topics.CLOSE */]: this.handleDataSendCloseEvent.bind(this),
            };
        }
    }
    /**
     * @private
     */
    handleControllerRemoved() {
        this.targetControlManagementService = undefined;
        this.targetControlService = undefined;
        this.siriService = undefined;
        this.audioStreamManagementService = undefined;
        this.eventHandler = undefined;
        this.requestHandler = undefined;
        this.dataStreamManagement?.destroy();
        this.dataStreamManagement = undefined;
        // the call to dataStreamManagement.destroy will close any open data stream connection
        // which will result in a call to this.handleDataStreamConnectionClosed, cleaning up this.dataStreamConnections.
        // It will also result in a call to SiriAudioSession.handleDataStreamConnectionClosed (if there are any open session)
        // which again results in a call to this.handleSiriAudioSessionClosed,cleaning up this.activeAudioSession and this.nextAudioSession.
    }
    /**
     * @private
     */
    handleFactoryReset() {
        debug("Running factory reset. Resetting targets...");
        this.handleResetTargets(undefined);
        this.lastButtonEvent = "";
    }
    /**
     * @private
     */
    serialize() {
        if (!this.activeIdentifier && Object.keys(this.targetConfigurations).length === 0) {
            return undefined;
        }
        return {
            activeIdentifier: this.activeIdentifier,
            targetConfigurations: [...this.targetConfigurations].reduce((obj, [key, value]) => {
                obj[key] = value;
                return obj;
            }, {}),
        };
    }
    /**
     * @private
     */
    deserialize(serialized) {
        this.activeIdentifier = serialized.activeIdentifier;
        this.targetConfigurations = Object.entries(serialized.targetConfigurations).reduce((map, [key, value]) => {
            const identifier = parseInt(key, 10);
            map.set(identifier, value);
            return map;
        }, new Map());
        this.updatedTargetConfiguration();
    }
    /**
     * @private
     */
    setupStateChangeDelegate(delegate) {
        this.stateChangeDelegate = delegate;
    }
}
exports.RemoteController = RemoteController;
/**
 * @group Apple TV Remote
 */
var SiriAudioSessionEvents;
(function (SiriAudioSessionEvents) {
    SiriAudioSessionEvents["CLOSE"] = "close";
})(SiriAudioSessionEvents || (exports.SiriAudioSessionEvents = SiriAudioSessionEvents = {}));
/**
 * Represents an ongoing audio transmission
 * @group Apple TV Remote
 */
// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
class SiriAudioSession extends events_1.EventEmitter {
    connection;
    selectedAudioConfiguration;
    producer;
    producerRunning = false; // indicates if the producer is running
    producerTimer; // producer has a 3s timeout to produce the first frame, otherwise transmission will be cancelled
    /**
     * @private file private API
     */
    state = 0 /* SiriAudioSessionState.STARTING */;
    streamId; // present when state >= SENDING
    endOfStream = false;
    audioFrameQueue = [];
    maxQueueSize = 1024;
    sequenceNumber = 0;
    closeListener;
    constructor(connection, selectedAudioConfiguration, producerConstructor, 
    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,@typescript-eslint/no-explicit-any
    producerOptions) {
        super();
        this.connection = connection;
        this.selectedAudioConfiguration = selectedAudioConfiguration;
        this.producer = new producerConstructor(this.handleSiriAudioFrame.bind(this), this.handleProducerError.bind(this), producerOptions);
        this.connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, this.closeListener = this.handleDataStreamConnectionClosed.bind(this));
    }
    /**
     * Called when siri button is pressed
     */
    start() {
        debug("Sending request to start siri audio stream");
        // opening dataSend
        this.connection.sendRequest("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, {
            target: "controller",
            type: "audio.siri",
        }, (error, status, message) => {
            if (this.state === 3 /* SiriAudioSessionState.CLOSED */) {
                debug("Ignoring dataSend open response as the session is already closed");
                return;
            }
            assert_1.default.strictEqual(this.state, 0 /* SiriAudioSessionState.STARTING */);
            this.state = 1 /* SiriAudioSessionState.SENDING */;
            if (error || status) {
                if (error) { // errors get produced by hap-nodejs
                    debug("Error occurred trying to start siri audio stream: %s", error.message);
                }
                else if (status) { // status codes are those returned by the hds response
                    debug("Controller responded with non-zero status code: %s", datastream_1.HDSStatus[status]);
                }
                this.closed();
            }
            else {
                this.streamId = message.streamId;
                if (!this.producerRunning) { // audio producer errored in the meantime
                    this.sendDataSendCloseEvent(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
                }
                else {
                    debug("Successfully setup siri audio stream with streamId %d", this.streamId);
                }
            }
        });
        this.startAudioProducer(); // start audio producer and queue frames in the meantime
    }
    /**
     * @returns if the audio session is closing
     */
    isClosing() {
        return this.state >= 2 /* SiriAudioSessionState.CLOSING */;
    }
    /**
     * Called when siri button is released (or active identifier is changed to another device)
     */
    stop() {
        (0, assert_1.default)(this.state <= 1 /* SiriAudioSessionState.SENDING */, "state was higher than SENDING");
        debug("Stopping siri audio stream with streamId %d", this.streamId);
        this.endOfStream = true; // mark as endOfStream
        this.stopAudioProducer();
        if (this.state === 1 /* SiriAudioSessionState.SENDING */) {
            this.handleSiriAudioFrame(undefined); // send out last few audio frames with endOfStream property set
            this.state = 2 /* SiriAudioSessionState.CLOSING */; // we are waiting for an acknowledgment (triggered by endOfStream property)
        }
        else { // if state is not SENDING (aka state is STARTING) the callback for DATA_SEND OPEN did not yet return (or never will)
            this.closed();
        }
    }
    startAudioProducer() {
        this.producer.startAudioProduction(this.selectedAudioConfiguration);
        this.producerRunning = true;
        this.producerTimer = setTimeout(() => {
            debug("Didn't receive any frames from audio producer for stream with streamId %s. Canceling the stream now.", this.streamId);
            this.producerTimer = undefined;
            this.handleProducerError(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
        }, 3000);
        this.producerTimer.unref();
    }
    stopAudioProducer() {
        this.producer.stopAudioProduction();
        this.producerRunning = false;
        if (this.producerTimer) {
            clearTimeout(this.producerTimer);
            this.producerTimer = undefined;
        }
    }
    handleSiriAudioFrame(frame) {
        if (this.state >= 2 /* SiriAudioSessionState.CLOSING */) {
            return;
        }
        if (this.producerTimer) { // if producerTimer is defined, then this is the first frame we are receiving
            clearTimeout(this.producerTimer);
            this.producerTimer = undefined;
        }
        if (frame && this.audioFrameQueue.length < this.maxQueueSize) { // add frame to queue whilst it is not full
            this.audioFrameQueue.push(frame);
        }
        if (this.state !== 1 /* SiriAudioSessionState.SENDING */) { // dataSend isn't open yet
            return;
        }
        let queued;
        while ((queued = this.popSome()) !== null) { // send packets
            const packets = [];
            queued.forEach(frame => {
                const packetData = {
                    data: frame.data,
                    metadata: {
                        rms: new datastream_1.Float32(frame.rms),
                        sequenceNumber: new datastream_1.Int64(this.sequenceNumber++),
                    },
                };
                packets.push(packetData);
            });
            const message = {
                packets: packets,
                streamId: new datastream_1.Int64(this.streamId),
                endOfStream: this.endOfStream,
            };
            try {
                this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "data" /* Topics.DATA */, message);
            }
            catch (error) {
                debug("Error occurred when trying to send audio frame of hds connection: %s", error.message);
                this.stopAudioProducer();
                this.closed();
            }
            if (this.endOfStream) {
                break; // popSome() returns empty list if endOfStream=true
            }
        }
    }
    handleProducerError(error) {
        if (this.state >= 2 /* SiriAudioSessionState.CLOSING */) {
            return;
        }
        this.stopAudioProducer(); // ensure backend is closed
        if (this.state === 1 /* SiriAudioSessionState.SENDING */) { // if state is less than sending dataSend isn't open (yet)
            this.sendDataSendCloseEvent(error); // cancel submission
        }
    }
    handleDataSendAckEvent(endOfStream) {
        assert_1.default.strictEqual(endOfStream, true);
        debug("Received acknowledgment for siri audio stream with streamId %s, closing it now", this.streamId);
        this.sendDataSendCloseEvent(0 /* HDSProtocolSpecificErrorReason.NORMAL */);
    }
    handleDataSendCloseEvent(reason) {
        // @ts-expect-error: forceConsistentCasingInFileNames compiler option
        debug("Received close event from controller with reason %s for stream with streamId %s", datastream_1.HDSProtocolSpecificErrorReason[reason], this.streamId);
        if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
            this.stopAudioProducer();
        }
        this.closed();
    }
    sendDataSendCloseEvent(reason) {
        (0, assert_1.default)(this.state >= 1 /* SiriAudioSessionState.SENDING */, "state was less than SENDING");
        (0, assert_1.default)(this.state <= 2 /* SiriAudioSessionState.CLOSING */, "state was higher than CLOSING");
        this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "close" /* Topics.CLOSE */, {
            streamId: new datastream_1.Int64(this.streamId),
            reason: new datastream_1.Int64(reason),
        });
        this.closed();
    }
    handleDataStreamConnectionClosed() {
        debug("Closing audio session with streamId %d", this.streamId);
        if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
            this.stopAudioProducer();
        }
        this.closed();
    }
    closed() {
        const lastState = this.state;
        this.state = 3 /* SiriAudioSessionState.CLOSED */;
        if (lastState !== 3 /* SiriAudioSessionState.CLOSED */) {
            this.emit("close" /* SiriAudioSessionEvents.CLOSE */);
            this.connection.removeListener("closed" /* DataStreamConnectionEvent.CLOSED */, this.closeListener);
        }
        this.removeAllListeners();
    }
    popSome() {
        if (this.audioFrameQueue.length < 5 && !this.endOfStream) {
            return null;
        }
        const size = Math.min(this.audioFrameQueue.length, 5); // 5 frames per hap packet seems fine
        const result = [];
        for (let i = 0; i < size; i++) {
            const element = this.audioFrameQueue.shift(); // removes first element
            result.push(element);
        }
        return result;
    }
}
exports.SiriAudioSession = SiriAudioSession;
//# sourceMappingURL=RemoteController.js.map