homebridge-pjlink/dist/InputSourceHandler.js

Homebridge accessory for PJLink supported projectors

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InputSourceHandler = void 0;
// import {PJLink} from 'PJLink';
const PJLink = require('pjlink');
class InputSourceHandler {
    constructor(log, api, accessory, device, config, tvService) {
        this.log = log;
        this.api = api;
        this.accessory = accessory;
        this.device = device;
        this.config = config;
        this.tvService = tvService;
        this.mockInputs = true;
        this.defaultInput = '31';
        this.inputs = [];
        this.inputServices = [];
        this.log = log;
        this.api = api;
        this.device = device;
        this.tvService = tvService;
        this.getInputSources(config.inputs);
        this.prepareTelevision();
    }
    getServices() {
        return this.inputServices;
    }
    prepareTelevision() {
        // hap
        const Characteristic = this.api.hap.Characteristic;
        this.tvService.getCharacteristic(Characteristic.ActiveIdentifier)
            .on("get" /* GET */, this.getActiveIdentifier.bind(this))
            .on("set" /* SET */, this.setActiveIdentifier.bind(this));
    }
    getInputSources(configured) {
        if (configured) {
            for (let i = 0; i < configured.length; i++) {
                configured[i].code = configured[i].source.toString() + configured[i].channel.toString();
            }
            this.setupInputs(configured);
        }
        else if (this.mockInputs) {
            this.setupInputs([
                { source: PJLink.INPUT.RGB, channel: 1, code: '11', name: 'RGB 1' },
                { source: PJLink.INPUT.RGB, channel: 2, code: '12', name: 'RGB 2' },
                { source: PJLink.INPUT.VIDEO, channel: 1, code: '21', name: 'VIDEO 1' },
                { source: PJLink.INPUT.VIDEO, channel: 2, code: '22', name: 'VIDEO 2' },
                { source: PJLink.INPUT.DIGITAL, channel: 1, code: '31', name: 'DIGITAL 1' },
            ]);
        }
        else {
            this.device.getInputs((error, inputs) => {
                if (inputs) {
                    this.setupInputs(inputs);
                }
            });
        }
    }
    setupInputs(inputs) {
        this.inputs = inputs;
        // hap
        const Service = this.api.hap.Service;
        const Characteristic = this.api.hap.Characteristic;
        // setup
        inputs.forEach((input) => {
            const identifier = input.code;
            const inputName = input.name;
            this.log.info(identifier, inputName);
            const inputSource = this.accessory.getService(identifier) ||
                this.accessory.addService(Service.InputSource, identifier, inputName);
            const inputType = this.mapInputType(input.source);
            inputSource
                .setCharacteristic(Characteristic.ConfiguredName, inputName)
                .setCharacteristic(Characteristic.InputSourceType, inputType)
                .setCharacteristic(Characteristic.IsConfigured, Characteristic.IsConfigured.CONFIGURED)
                .setCharacteristic(Characteristic.CurrentVisibilityState, Characteristic.CurrentVisibilityState.SHOWN)
                .setCharacteristic(Characteristic.Identifier, identifier);
            inputSource.getCharacteristic(this.api.hap.Characteristic.ConfiguredName)
                .on("set" /* SET */, this.setConfiguredInputSourceName.bind(this, identifier));
            if (input.code === this.defaultInput) {
                this.activeIdentifier = identifier;
                this.tvService.updateCharacteristic(Characteristic.ActiveIdentifier, this.activeIdentifier);
            }
            this.tvService.addLinkedService(inputSource);
            this.inputServices.push(inputSource);
        });
    }
    getActiveIdentifier(callback) {
        this.log.info('get active identifier', this.activeIdentifier);
        callback(null, this.activeIdentifier);
    }
    setActiveIdentifier(value, callback) {
        try {
            this.log.info('set active identifier', value);
            let activeInput = null;
            for (let i = 0; i < this.inputs.length; i++) {
                const input = this.inputs[i];
                if (input.code === value) {
                    activeInput = input;
                }
            }
            if (activeInput !== null) {
                this.device.setInput(activeInput, (error) => {
                    if (error) {
                        callback(new Error(error));
                    }
                    else {
                        callback();
                    }
                });
            }
        }
        catch (e) {
            this.log.error(e);
            callback(e);
        }
    }
    update() {
        try {
            this.device.getInput((error, input) => {
                if (error) {
                    this.log.error(error);
                }
                else {
                    if (input && input.code !== this.activeIdentifier) {
                        this.activeIdentifier = input.code;
                        const Characteristic = this.api.hap.Characteristic;
                        this.tvService.updateCharacteristic(Characteristic.ActiveIdentifier, this.activeIdentifier);
                    }
                }
            });
        }
        catch (e) {
            this.log.error(e);
        }
    }
    mapInputType(type) {
        // hap
        const Characteristic = this.api.hap.Characteristic;
        switch (type) {
            case PJLink.INPUT.RGB:
                return Characteristic.InputSourceType.COMPONENT_VIDEO;
            case PJLink.INPUT.DIGITAL:
                return Characteristic.InputSourceType.HDMI;
            case PJLink.INPUT.NETWORK:
                return Characteristic.InputSourceType.AIRPLAY;
            case PJLink.INPUT.VIDEO:
                return Characteristic.InputSourceType.S_VIDEO;
            case PJLink.INPUT.STORAGE:
                return Characteristic.InputSourceType.USB;
            default:
                return Characteristic.InputSourceType.OTHER;
        }
    }
    setConfiguredInputSourceName(inputIdentifier, value, callback) {
        this.log.info('Set input value', inputIdentifier, value);
        // this.accessory.context.inputLabels[inputIdentifier] = value;
        callback();
    }
}
exports.InputSourceHandler = InputSourceHandler;
//# sourceMappingURL=InputSourceHandler.js.map