homebridge-sony-audio-extended 0.0.1

package/dist/sonyDevice.js

@@ -0,0 +1,867 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonyDevice = void 0;
+const api_1 = require("./api");
+const axios_1 = __importDefault(require("axios"));
+const events_1 = require("events");
+/* eslint-disable max-len */
+const url_1 = require("url");
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Categories of devices supported by this module
+ */
+const COMPATIBLE_DEVICE_CATEGORIES = [
+    'homeTheaterSystem',
+    'personalAudio', // !not tested
+];
+/**
+ * Model names that are explicitly supported even if category doesn't match
+ */
+const COMPATIBLE_DEVICE_MODELS = ['STR-AN1000'];
+/**
+ * Devices terminals which hasn't in getCurrentExternalTerminalsStatus api
+ * from [here](https://developer.sony.com/develop/audio-control-api/api-references/device-uri)
+ */
+const DEVICE_TERMINALS = [
+    {
+        scheme: 'dlna',
+        readonly: true,
+        terminal: {
+            connection: 'connected',
+            title: 'DLNA Music',
+            uri: 'dlna:music',
+            meta: "meta:pc" /* PC */,
+        },
+    },
+    {
+        scheme: 'storage',
+        readonly: true,
+        terminal: {
+            connection: 'connected',
+            title: 'USB Storage',
+            uri: 'storage:usb1',
+            meta: "meta:usbdac" /* USBDAC */,
+        },
+    },
+    {
+        scheme: 'radio',
+        readonly: true,
+        terminal: {
+            connection: 'connected',
+            title: 'FM Radio',
+            uri: 'radio:fm',
+            meta: "meta:tuner" /* TUNER */,
+        },
+    },
+    {
+        scheme: 'netService',
+        readonly: false,
+        terminal: {
+            connection: 'connected',
+            title: 'Audio Network',
+            uri: 'netService:audio',
+            meta: "meta:source" /* SOURCE */,
+        },
+    },
+    {
+        scheme: 'multiroom',
+        readonly: false,
+        terminal: {
+            connection: 'connected',
+            title: 'Multiroom Audio',
+            uri: 'multiroom:audio',
+            meta: "meta:source" /* SOURCE */,
+        },
+    },
+    {
+        scheme: 'cast',
+        readonly: false,
+        terminal: {
+            connection: 'connected',
+            title: 'Cast Audio',
+            uri: 'cast:audio',
+            meta: "meta:source" /* SOURCE */,
+        },
+    },
+    {
+        scheme: 'extInput',
+        readonly: false,
+        terminal: {
+            connection: 'connected',
+            title: 'AirPlay',
+            uri: 'extInput:airPlay',
+            meta: "meta:btaudio" /* BTAUDIO */,
+        },
+    },
+];
+const RE_EXT_OUTPUT = new RegExp('extOutput:*');
+const SUBSCRIBE_NOTIFICATIONS = [
+    {
+        service: 'system',
+        notifications: ["notifyPowerStatus" /* POWER */],
+    },
+    {
+        service: 'audio',
+        notifications: ["notifyVolumeInformation" /* VOLUME */],
+    },
+    {
+        service: 'avContent',
+        notifications: ["notifyExternalTerminalStatus" /* TERMINAL */, "notifyPlayingContentInfo" /* CONTENT */],
+    },
+];
+const RECONNECT_TIMEOUT = 5000;
+const REQUEST_TIMEOUT = 5000;
+const WEBSOCKET_REQUEST_TIMEOUT = 3000;
+const WEBSOCKET_HEARTBEAT_INTERVAL = 60 * 1000;
+class SonyDevice extends events_1.EventEmitter {
+    constructor(baseUrl, upnpUrl, udn, apisInfo, log) {
+        super();
+        /** Flag for emitting of the RESORE event, rised when connection has been lost and after restored */
+        this.emitRestoreEvent = false;
+        this.systemInfo = {
+            area: '',
+            bdAddr: '',
+            bleID: '',
+            cid: '',
+            deviceID: '',
+            duid: '',
+            esn: '',
+            generation: '',
+            helpUrl: '',
+            iconUrl: '',
+            initialPowerOnTime: '',
+            language: '',
+            lastPowerOnTime: '',
+            macAddr: '',
+            model: '',
+            name: '',
+            product: '',
+            region: '',
+            serial: '',
+            ssid: '',
+            version: '',
+            wirelessMacAddr: '',
+        };
+        this._externalTerminals = null;
+        this._volumeInformation = null;
+        this.manufacturer = 'Sony Corporation';
+        this.readyState = SonyDevice.CREATING;
+        this.baseUrl = baseUrl;
+        this.upnpUrl = upnpUrl;
+        this.UDN = udn;
+        this.apisInfo = apisInfo;
+        this.log = log;
+        // this.systemInfo = systemInfo;
+        this.axiosInstance = axios_1.default.create({
+            baseURL: this.baseUrl.href,
+            headers: { 'content-type': 'application/json' },
+            timeout: REQUEST_TIMEOUT,
+        });
+        this.axiosInstance.interceptors.response.use(SonyDevice.responseInterceptor(this.log));
+        this.axiosInstance.interceptors.request.use(SonyDevice.requestInterceptorLogger(this.log));
+        if (this.upnpUrl) {
+            this.axiosInstanceSoap = axios_1.default.create({
+                baseURL: this.upnpUrl.href,
+                headers: {
+                    SOAPACTION: '"urn:schemas-sony-com:service:IRCC:1#X_SendIRCC"',
+                    'Content-Type': 'text/xml; charset="utf-8"',
+                },
+                timeout: REQUEST_TIMEOUT,
+            });
+            this.axiosInstanceSoap.interceptors.response.use(SonyDevice.responseInterceptor(this.log));
+            this.axiosInstanceSoap.interceptors.request.use(SonyDevice.requestInterceptorLogger(this.log));
+        }
+        this.wsClients = new Map();
+        this.readyState = SonyDevice.READY;
+    }
+    /**
+     * Return device id
+     */
+    getDeviceID() {
+        return this.systemInfo.serial !== ''
+            ? this.systemInfo.serial
+            : this.systemInfo.macAddr !== ''
+                ? this.systemInfo.macAddr
+                : this.systemInfo.wirelessMacAddr;
+    }
+    /**
+     * Checks the request for API version compliance
+     */
+    validateRequest(service, request) {
+        var _a;
+        const version = request.version;
+        const method = request.method;
+        const reqApis = (_a = this.apisInfo) === null || _a === void 0 ? void 0 : _a.find((a) => a.service === service);
+        const reqApi = reqApis === null || reqApis === void 0 ? void 0 : reqApis.apis.find((m) => m.name === method);
+        const validVersions = reqApi === null || reqApi === void 0 ? void 0 : reqApi.versions.map((x) => x.version);
+        if (validVersions) {
+            return validVersions.includes(version);
+        }
+        else {
+            return false;
+        }
+    }
+    async getExternalTerminals() {
+        if (!this._externalTerminals) {
+            // get the terminals info from device
+            const resTerminals = await this.axiosInstance.post('/avContent', JSON.stringify(api_1.ApiRequestCurrentExternalTerminalsStatus));
+            const terminals = resTerminals.data;
+            this._externalTerminals = terminals.result[0];
+            // add other terminals
+            const schemes = await this.getSchemes();
+            DEVICE_TERMINALS.forEach((t) => {
+                var _a, _b;
+                if (t.readonly) {
+                    if (schemes.includes(t.scheme)) {
+                        // device support that input terminal
+                        (_a = this._externalTerminals) === null || _a === void 0 ? void 0 : _a.push(t.terminal);
+                    }
+                }
+                else {
+                    // add all readonly terminals
+                    (_b = this._externalTerminals) === null || _b === void 0 ? void 0 : _b.push(t.terminal);
+                }
+            });
+        }
+        return this._externalTerminals;
+    }
+    /**
+     * Terminal is read-only and cannot be select by the user?
+     */
+    isReadonlyTerminal(terminal) {
+        const readonlyTerminalsUri = DEVICE_TERMINALS.find((t) => !t.readonly && t.terminal.uri === terminal.uri);
+        return !!readonlyTerminalsUri;
+    }
+    async getVolumeInformation() {
+        if (!this._volumeInformation) {
+            // get the volume info from device
+            const resVolumes = await this.axiosInstance.post('/audio', JSON.stringify(api_1.ApiRequestVolumeInformation));
+            const volumes = resVolumes.data;
+            this._volumeInformation = volumes.result[0];
+        }
+        return this._volumeInformation;
+    }
+    /**
+     * Returns the active input (if exist) for current active zone
+     */
+    async getActiveInput() {
+        const service = 'avContent';
+        const req = {
+            id: 37,
+            method: 'getPlayingContentInfo',
+            params: [{}],
+            version: '1.2',
+        };
+        const zone = await this.getActiveZone();
+        if (zone) {
+            req.params[0].output = zone.uri;
+        }
+        const res = await this.axiosInstance.post('/' + service, JSON.stringify(req));
+        const playingInfo = res.data;
+        if (playingInfo.result[0].length === 1) {
+            // info with only one zone
+            return this.getTerminalBySource(playingInfo.result[0][0].source || playingInfo.result[0][0].uri);
+        }
+        return null; // no active zone
+    }
+    /**
+     * Return external terminals which are inputs
+     */
+    async getInputs() {
+        const exTerminals = await this.getExternalTerminals();
+        const inputs = exTerminals === null || exTerminals === void 0 ? void 0 : exTerminals.filter((t) => !RE_EXT_OUTPUT.test(t.uri));
+        return inputs ? inputs : [];
+    }
+    /**
+     * Return external terminals which are zone, aka outputs
+     */
+    async getZones() {
+        const exTerminals = await this.getExternalTerminals();
+        const inputs = exTerminals === null || exTerminals === void 0 ? void 0 : exTerminals.filter((t) => RE_EXT_OUTPUT.test(t.uri));
+        return inputs ? inputs : null;
+    }
+    /**
+     * Return active zone.
+     * If no active zone, return `null`.
+     * It's mean that only one zone exist, i.e. no output terminals
+     */
+    async getActiveZone() {
+        const zones = await this.getZones();
+        if (zones === null) {
+            return null;
+        }
+        else {
+            const activeZone = zones.find((zone) => zone.active === 'active');
+            return activeZone ? activeZone : null;
+        }
+    }
+    /**
+     * Return the list of schemes that device can handle.
+     */
+    async getSchemes() {
+        const resSchemes = await this.axiosInstance.post('/avContent', JSON.stringify(api_1.ApiRequestGetSchemeList));
+        const schemes = resSchemes.data;
+        return schemes.result[0].map((s) => s.scheme);
+    }
+    /**
+     * Check the API response for returned error
+     * Decsription of errors [here](https://developer.sony.com/develop/audio-control-api/api-references/error-codes).
+     * @param response
+     */
+    static responseInterceptor(log) {
+        return (response) => {
+            log.debug(`Response from device:\n${JSON.stringify(response.data)}`);
+            if (typeof response.data === 'object' && response.data !== null) {
+                if ('error' in response.data) {
+                    // TODO: add a device ip address for identification of the device
+                    const errMsg = `Device API got an error: ${JSON.stringify(response.data)}`;
+                    return Promise.reject(new api_1.GenericApiError(errMsg));
+                }
+                else {
+                    return response;
+                }
+            }
+            else {
+                return response;
+            }
+        };
+    }
+    /**
+     * Logging requests for debug
+     * @param request
+     */
+    static requestInterceptorLogger(log) {
+        return (request) => {
+            log.debug(`Request to device\n${request.baseURL}:\n${JSON.stringify(request.data)}`);
+            return request;
+        };
+    }
+    /**
+     * Create and initialize the new device.
+     * Get info about supported api and system
+     */
+    static async createDevice(baseUrl, upnpUrl, udn, log) {
+        const axiosInstance = axios_1.default.create({
+            baseURL: baseUrl.href,
+            headers: { 'content-type': 'application/json' },
+            timeout: 0, // when device is turning on, some time it has long answer time.
+        });
+        axiosInstance.interceptors.response.use(SonyDevice.responseInterceptor(log));
+        axiosInstance.interceptors.request.use(SonyDevice.requestInterceptorLogger(log));
+        // Checks the device against a compatible category of the device
+        const resInterfaceInfo = await axiosInstance.post('/system', JSON.stringify(api_1.ApiRequestGetInterfaceInformation));
+        const interfaceInfo = resInterfaceInfo.data;
+        const productCategory = interfaceInfo.result[0].productCategory;
+        const modelName = interfaceInfo.result[0].modelName;
+        // Log device information for debugging
+        log.debug(`Device info - Model: "${modelName}", Category: "${productCategory}"`);
+        // Check if device is compatible by category or by model name
+        const isCompatibleCategory = COMPATIBLE_DEVICE_CATEGORIES.includes(productCategory);
+        const isCompatibleModel = COMPATIBLE_DEVICE_MODELS.some((model) => modelName && modelName.toUpperCase().includes(model.toUpperCase()));
+        if (!isCompatibleCategory && !isCompatibleModel) {
+            // device has an incompatible category and is not in the compatible models list
+            throw new api_1.IncompatibleDeviceCategoryError(`Device at ${baseUrl.href} has an incompatible category "${productCategory}" and model "${modelName}" is not in the supported models list`);
+        }
+        const resApiInfo = await axiosInstance.post('/guide', JSON.stringify(api_1.ApiRequestSupportedApiInfo));
+        const apisInfo = resApiInfo.data.result[0];
+        const device = new SonyDevice(baseUrl, upnpUrl, udn, apisInfo, log);
+        // Gets general system information for the device.
+        // check the request for API version compliance
+        const service = 'system';
+        if (!device.validateRequest(service, api_1.ApiRequestSystemInformation)) {
+            throw new api_1.UnsupportedVersionApiError(`The specified api version is not supported by the device ${baseUrl.hostname}`);
+        }
+        const resSystemInfo = await axiosInstance.post('/' + service, JSON.stringify(api_1.ApiRequestSystemInformation));
+        const systemInfo = resSystemInfo.data.result[0];
+        Object.assign(device.systemInfo, systemInfo);
+        device.subscribe();
+        return device;
+    }
+    /**
+     * Initialize notifications for given events
+     */
+    subscribe() {
+        SUBSCRIBE_NOTIFICATIONS.forEach((subscriber) => this.createWebSocket(subscriber.service));
+    }
+    /**
+     * Disable all notifications subscriptions and close websocket connections
+     */
+    unsubscribe() {
+        this.readyState = SonyDevice.CLOSING;
+        this.wsClients.forEach((ws, service) => {
+            this.log.debug(`Device ${this.systemInfo.name} unsubscribing from ${service} service`);
+            // unsubscribe from all notifications
+            const disables = this.getAvailibleNotifications(service);
+            if (ws.readyState === ws_1.default.OPEN) {
+                ws.send(JSON.stringify(this.switchNotifications(100, disables, [])));
+            }
+        });
+    }
+    /**
+     * Create a new socket for the given service.
+     * If socket already exist, only request current notifications subscriptions
+     * @param service
+     * @returns
+     */
+    createWebSocket(service) {
+        if (this.wsClients.has(service)) {
+            // if socket already created, request current notifications subscriptions
+            const ws = this.wsClients.get(service);
+            if (ws['subscriptionCommand']) {
+                ws.send(ws['subscriptionCommand']);
+            }
+            return;
+        }
+        const url = new url_1.URL(this.baseUrl.href);
+        url.protocol = 'ws';
+        url.pathname = url.pathname + '/' + service;
+        const ws = new ws_1.default(url);
+        function heartbeat(device) {
+            device.log.debug(`Device ${device.systemInfo.name} heartbeat init`);
+            ws['isAlive'] = true;
+            ws['heartbeat'] = setInterval(() => {
+                if (ws['isAlive'] === false) {
+                    ws.terminate();
+                    return;
+                }
+                device.log.debug(`Device ${device.systemInfo.name} heartbeat`);
+                if (ws['subscriptionCommand']) {
+                    ws.send(ws['subscriptionCommand']);
+                }
+                ws['heartbeatTimeout'] = setTimeout(() => {
+                    device.log.debug(`Device ${device.systemInfo.name} heartbeat timeout`);
+                    ws['isAlive'] = false;
+                    ws.terminate();
+                }, WEBSOCKET_REQUEST_TIMEOUT);
+            }, WEBSOCKET_HEARTBEAT_INTERVAL);
+        }
+        ws.on('open', () => {
+            this.log.debug(`Device ${this.systemInfo.name} opened a socked ${url.href}`);
+            heartbeat(this);
+            // To get current notification settings, send an empty 'switchNotifications'
+            // message with an ID of '1'
+            ws.send(JSON.stringify(this.switchNotifications(1, [], [])));
+        });
+        ws.on('message', (data) => {
+            const response = JSON.parse(data);
+            if ('id' in response) {
+                if (response.id === 1) {
+                    // enable notification
+                    this.log.debug(`Device ${this.systemInfo.name} received initial message ${data}`);
+                    const enabled = []; // response.result[0].enabled;
+                    const disabled = []; // response.result[0].disabled;
+                    const shouldEnabled = SUBSCRIBE_NOTIFICATIONS.filter((s) => s.service === service)[0].notifications;
+                    // if shouldEnabled equal to returned enabled, this mean what nothing to do. All ok
+                    if (shouldEnabled.length === enabled.length) {
+                        return;
+                    }
+                    // else we need to resubscribe
+                    const all_notifications = [...response.result[0].enabled].concat([
+                        ...response.result[0].disabled,
+                    ]);
+                    for (let i = 0; i < all_notifications.length; i++) {
+                        const item = all_notifications[i];
+                        if (shouldEnabled.includes(item.name)) {
+                            enabled.push(item);
+                        }
+                        else {
+                            disabled.push(item);
+                        }
+                    }
+                    if (shouldEnabled.length !== enabled.length) {
+                        // something wrong... or not. For example HT-ZF9 hasn't a notifyExternalTerminalStatus. See #1
+                        this.log.debug(`Device ${this.systemInfo.name} does not have the required notifier. Should be ${JSON.stringify(shouldEnabled)}, but found ${JSON.stringify(enabled)}`);
+                    }
+                    this.log.debug(`Device ${this.systemInfo.name} sent subscribe message ${JSON.stringify(this.switchNotifications(2, disabled, enabled))}`);
+                    ws['subscriptionCommand'] = JSON.stringify(this.switchNotifications(2, disabled, enabled));
+                    ws.send(ws['subscriptionCommand']);
+                }
+                else if (response.id === 100) {
+                    // unsubscribe from notifications
+                    clearInterval(ws['heartbeat']);
+                    clearTimeout(ws['heartbeatTimeout']);
+                    ws.terminate();
+                }
+                else {
+                    this.log.debug(`Device ${this.systemInfo.name} received subscription status ${data}`);
+                    if (this.emitRestoreEvent) {
+                        this.emitRestoreEvent = false;
+                        this.emit("restore" /* RESTORE */);
+                    }
+                }
+            }
+            else {
+                // here handle received notification
+                this.log.debug(`Device ${this.systemInfo.name} received notification ${data}`);
+                this.handleNotificationMessage(response);
+            }
+            clearTimeout(ws['heartbeatTimeout']);
+        });
+        ws.on('close', () => {
+            this.log.debug(`Device ${this.systemInfo.name} socket closed`);
+            this.wsClients.delete(service);
+            // If the connection was closed illegally, recreate it.
+            if (this.readyState !== SonyDevice.CLOSING) {
+                setTimeout(() => {
+                    this.emitRestoreEvent = true;
+                    this.createWebSocket(service);
+                }, RECONNECT_TIMEOUT);
+            }
+        });
+        ws.on('error', (err) => {
+            this.log.debug(`ERROR: Device ${this.systemInfo.name} has a comunication error: ${err.message}`);
+            if (this.wsClients.has(service)) {
+                this.wsClients.get(service).terminate();
+            }
+            this.wsClients.delete(service);
+        });
+        this.wsClients.set(service, ws);
+    }
+    /**
+     * A switchNotifications Request
+     * taken [here](https://developer.sony.com/develop/audio-control-api/get-started/websocket-example#tutorial-step-3)
+     * @param id
+     * @param disable
+     * @param enable
+     */
+    switchNotifications(id, disable, enable) {
+        return {
+            method: 'switchNotifications',
+            id: id,
+            params: [
+                {
+                    disabled: disable,
+                    enabled: enable,
+                },
+            ],
+            version: '1.0',
+        };
+    }
+    /**
+     * Returns all availible notifications of the device
+     * @param service
+     * @returns
+     */
+    getAvailibleNotifications(service) {
+        const serviceApiInfo = this.apisInfo.find((v) => v.service === service);
+        if (!serviceApiInfo) {
+            return [];
+        }
+        const notifications = [];
+        for (let i = 0; i < serviceApiInfo.notifications.length; i++) {
+            const notification = serviceApiInfo.notifications[i];
+            for (let j = 0; j < notification.versions.length; j++) {
+                const version = notification.versions[j];
+                const verNotification = {
+                    name: notification.name,
+                    version: version.version,
+                };
+                notifications.push(verNotification);
+            }
+        }
+        return notifications;
+    }
+    /**
+     * Parse the notification message recieved from device
+     * @param message
+     */
+    handleNotificationMessage(message) {
+        switch (message.method) {
+            case "notifyPowerStatus" /* POWER */: {
+                const msg = message;
+                const power = msg.params[0].status === 'active';
+                this.emit("power" /* POWER */, power);
+                break;
+            }
+            case "notifyVolumeInformation" /* VOLUME */: {
+                const msg = message;
+                const volumeInfo = msg.params[0];
+                // update _volumeInformation
+                if (this._volumeInformation) {
+                    const volumeIdx = this._volumeInformation.findIndex((v) => v.output === volumeInfo.output);
+                    if (volumeIdx !== -1) {
+                        Object.assign(this._volumeInformation[volumeIdx], volumeInfo);
+                    }
+                }
+                const mute = volumeInfo.mute === 'on'
+                    ? true
+                    : volumeInfo.mute === 'off'
+                        ? false
+                        : null;
+                const volume = volumeInfo.volume;
+                if (volume !== -1) {
+                    this.emit("volume" /* VOLUME */, volume);
+                }
+                if (mute !== null) {
+                    this.emit("mute" /* MUTE */, mute);
+                }
+                break;
+            }
+            case "notifyPlayingContentInfo" /* CONTENT */: {
+                // receive like {"method":"notifyPlayingContentInfo","params":[{"contentKind":"input","output":"extOutput:zone?zone=1","source":"extInput:video?port=1","uri":"extInput:video?port=1"}],"version":"1.0"}
+                const msg = message;
+                const source = msg.params[0].source || msg.params[0].uri; // maybe overcheck
+                this.emit("source" /* SOURCE */, source);
+                break;
+            }
+            case "notifyExternalTerminalStatus" /* TERMINAL */: {
+                // receive like {"method":"notifyExternalTerminalStatus","params":[{"active":"active","connection":"connected","label":"","uri":"extOutput:zone?zone=1"}],"version":"1.0"}
+                const msg = message;
+                // update _externalTerminals
+                msg.params.forEach((updateTerminal) => {
+                    if (this._externalTerminals) {
+                        const terminalIdx = this._externalTerminals.findIndex((t) => t.uri === updateTerminal.uri);
+                        if (terminalIdx !== -1) {
+                            Object.assign(this._externalTerminals[terminalIdx], updateTerminal);
+                        }
+                        else {
+                            this._externalTerminals.push(updateTerminal);
+                        }
+                    }
+                });
+                // if the device is turning off from an external source, a notivication about power doesn't sends.
+                // so, force the power status check
+                this.getPowerState().then((active) => {
+                    this.emit("power" /* POWER */, active);
+                });
+                break;
+            }
+            default: {
+                this.log.error(`Found not implemented notification from device: ${JSON.stringify(message)}`);
+                break;
+            }
+        }
+    }
+    /**
+     * Find a terminal by source name
+     * @param source the source name received from notifyPlayingContentInfo event
+     */
+    getTerminalBySource(source) {
+        if (this._externalTerminals === null) {
+            return null;
+        }
+        const terminals = this._externalTerminals.filter((terminal) => terminal.uri === source);
+        if (terminals.length !== 0) {
+            return terminals[0];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Get current power state.
+     * * `true` if power is on
+     */
+    async getPowerState() {
+        const service = 'system';
+        const resPowerInfo = await this.axiosInstance.post('/' + service, JSON.stringify(api_1.ApiRequestGetPowerStatus));
+        const powerInfo = resPowerInfo.data;
+        return (powerInfo.result[0].status === 'activating' ||
+            powerInfo.result[0].status === 'active');
+    }
+    /**
+     * Get current volume state with device volume settings
+     * Volume state returns only for active zone. If no active zone then returns null
+     */
+    async getVolumeState() {
+        const service = 'audio';
+        const resVolumeInfo = await this.axiosInstance.post('/' + service, JSON.stringify(api_1.ApiRequestVolumeInformation));
+        const volumeInfo = resVolumeInfo.data;
+        const activeZone = await this.getActiveZone();
+        if (activeZone) {
+            const volumeActiveZone = volumeInfo.result[0].find((vi) => vi.output === activeZone.uri);
+            if (volumeActiveZone) {
+                return volumeActiveZone;
+            }
+        }
+        return null; // no active zone
+    }
+    /**
+     * Change the audio volume level for the active output zone
+     * @param volumeSelector the same as Characteristic.VolumeSelector in homebridge
+     * * `0` - increment
+     * * `1` - decrement
+     */
+    async setVolume(volumeSelector) {
+        const service = 'audio';
+        const zone = await this.getActiveZone();
+        const reqSetVolume = {
+            id: 98,
+            method: 'setAudioVolume',
+            params: [
+                {
+                    output: zone ? zone.uri : '',
+                    volume: volumeSelector === 0 ? '+1' : '-1',
+                },
+            ],
+            version: '1.1',
+        };
+        await this.axiosInstance.post('/' + service, JSON.stringify(reqSetVolume));
+        return volumeSelector;
+    }
+    /**
+     * Sets the power status of the device.
+     * @param power
+     * * `true` - set device in the power-on state
+     * * `false` - set device in the power-off state
+     */
+    async setPower(power) {
+        const service = 'system';
+        const reqSetPower = {
+            id: 55,
+            method: 'setPowerStatus',
+            params: [
+                {
+                    status: power ? 'active' : 'off',
+                },
+            ],
+            version: '1.1',
+        };
+        await this.axiosInstance.post('/' + service, JSON.stringify(reqSetPower));
+        return power;
+    }
+    /**
+     * Sets the audio mute status.
+     * @param mute
+     * * `true` - muted
+     * * `false` - not muted
+     */
+    async setMute(mute) {
+        const service = 'audio';
+        const zone = await this.getActiveZone();
+        const reqSetMute = {
+            id: 601,
+            method: 'setAudioMute',
+            params: [
+                {
+                    mute: mute ? 'on' : 'off',
+                },
+            ],
+            version: '1.1',
+        };
+        if (zone) {
+            reqSetMute.params[0].output = zone.uri;
+        }
+        await this.axiosInstance.post('/' + service, JSON.stringify(reqSetMute));
+        return mute;
+    }
+    /**
+     * Sets the input source
+     * @param terminal
+     */
+    async setSource(terminal) {
+        const service = 'avContent';
+        const zone = await this.getActiveZone();
+        const reqSetPlayContent = {
+            id: 47,
+            method: 'setPlayContent',
+            params: [
+                {
+                    uri: terminal.uri,
+                },
+            ],
+            version: '1.2',
+        };
+        if (zone) {
+            reqSetPlayContent.params[0].output = zone.uri;
+        }
+        await this.axiosInstance.post('/' + service, JSON.stringify(reqSetPlayContent));
+        return terminal;
+    }
+    /**
+     * Toggles between the play and pause states for the current content.
+     */
+    async setPause() {
+        const service = 'avContent';
+        const zone = await this.getActiveZone();
+        const reqPausePlayingContent = {
+            id: 31,
+            method: 'pausePlayingContent',
+            params: [{}],
+            version: '1.1',
+        };
+        if (zone) {
+            reqPausePlayingContent.params[0].output = zone.uri;
+        }
+        await this.axiosInstance.post('/' + service, JSON.stringify(reqPausePlayingContent));
+        return;
+    }
+    /**
+     * Sends command codes of IR remote commander to device via IP
+     * Some info [here](https://pro-bravia.sony.net/develop/integrate/ircc-ip/overview/index.html)
+     * @param irCode
+     */
+    async sendIRCC(irCode) {
+        if (this.axiosInstanceSoap) {
+            const data = `<?xml version="1.0" encoding="utf-8"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:X_SendIRCC xmlns:u="urn:schemas-sony-com:service:IRCC:1"><IRCCCode>${irCode}</IRCCCode></u:X_SendIRCC></s:Body></s:Envelope>`;
+            await this.axiosInstanceSoap.post('', data);
+        }
+    }
+    /**
+     * Press Arrow Up to select the menu items
+     * @returns
+     */
+    async setUp() {
+        const irccCode = 'AAAAAgAAALAAAAB4AQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Arrow Down to select the menu items
+     * @returns
+     */
+    async setDown() {
+        const irccCode = 'AAAAAgAAALAAAAB5AQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Arrow Right to select the menu items
+     * @returns
+     */
+    async setRigth() {
+        const irccCode = 'AAAAAgAAALAAAAB7AQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Arrow Left to select the menu items
+     * @returns
+     */
+    async setLeft() {
+        const irccCode = 'AAAAAgAAALAAAAB6AQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Select to enter the selection
+     * @returns
+     */
+    async setSelect() {
+        const irccCode = 'AAAAAgAAADAAAAAMAQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Back for returns to the previous menu or exits a menu
+     * @returns
+     */
+    async setBack() {
+        const irccCode = 'AAAAAwAAARAAAAB9AQ==';
+        return this.sendIRCC(irccCode);
+    }
+    /**
+     * Press Information for view some info
+     * @returns
+     */
+    async setInformation() {
+        const irccCode = 'AAAAAgAAADAAAABTAQ==';
+        return this.sendIRCC(irccCode);
+    }
+}
+exports.SonyDevice = SonyDevice;
+/** The device is creating. */
+SonyDevice.CREATING = 0;
+/** The device is ready to communicate. */
+SonyDevice.READY = 1;
+/** The device is in the process of closing. */
+SonyDevice.CLOSING = 2;
+//# sourceMappingURL=sonyDevice.js.map