homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/CameraAccessory.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaStreamDelegate_1 = require("../util/TuyaStreamDelegate");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Light_1 = require("./characteristic/Light");
+const On_1 = require("./characteristic/On");
+const ProgrammableSwitchEvent_1 = require("./characteristic/ProgrammableSwitchEvent");
+const SCHEMA_CODE = {
+    MOTION_ON: ['motion_switch'],
+    MOTION_DETECT: ['movement_detect_pic'],
+    // Indicates that this is possibly a doorbell
+    DOORBELL: ['doorbell_ring_exist'],
+    // Notifies when a doorbell ring occurs.
+    DOORBELL_RING: ['doorbell_pic'],
+    // Notifies when a doorbell ring occurs.
+    ALARM_MESSAGE: ['alarm_message'],
+    LIGHT_ON: ['floodlight_switch'],
+    LIGHT_BRIGHT: ['floodlight_lightness'],
+};
+class CameraAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [];
+    }
+    configureServices() {
+        this.configureDoorbell();
+        this.configureCamera();
+        this.configureMotion();
+        this.configureFloodLight();
+    }
+    configureMotion() {
+        const onSchema = this.getSchema(...SCHEMA_CODE.MOTION_ON);
+        if (onSchema) {
+            const onService = this.accessory.getService(onSchema.code)
+                || this.accessory.addService(this.Service.Switch, onSchema.code, onSchema.code);
+            (0, On_1.configureOn)(this, onService, onSchema);
+        }
+        this.getMotionService().setCharacteristic(this.Characteristic.MotionDetected, false);
+    }
+    configureDoorbell() {
+        // Check to see if it is indeed a doorbell.
+        if (!this.getSchema(...SCHEMA_CODE.DOORBELL)) {
+            return;
+        }
+        const schema = this.getSchema(...SCHEMA_CODE.DOORBELL_RING, ...SCHEMA_CODE.ALARM_MESSAGE);
+        if (!schema) {
+            return;
+        }
+        (0, ProgrammableSwitchEvent_1.configureProgrammableSwitchEvent)(this, this.getDoorbellService(), schema);
+    }
+    configureCamera() {
+        if (this.stream !== undefined) {
+            return;
+        }
+        if (this.device.isVirtualDevice()) {
+            return;
+        }
+        this.stream = new TuyaStreamDelegate_1.TuyaStreamingDelegate(this);
+        this.accessory.configureController(this.stream.controller);
+    }
+    configureFloodLight() {
+        if (!this.getSchema(...SCHEMA_CODE.LIGHT_ON)) {
+            return;
+        }
+        (0, Light_1.configureLight)(this, this.getLightService(), this.getSchema(...SCHEMA_CODE.LIGHT_ON), this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT), undefined, undefined, undefined);
+    }
+    getLightService() {
+        return this.accessory.getService(this.Service.Lightbulb)
+            || this.accessory.addService(this.Service.Lightbulb, this.accessory.displayName + ' Floodlight');
+    }
+    getDoorbellService() {
+        return this.accessory.getService(this.Service.Doorbell)
+            || this.accessory.addService(this.Service.Doorbell);
+    }
+    getMotionService() {
+        return this.accessory.getService(this.Service.MotionSensor)
+            || this.accessory.addService(this.Service.MotionSensor, this.accessory.displayName + ' Motion Detect');
+    }
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        const doorbellRingSchema = this.getSchema(...SCHEMA_CODE.DOORBELL_RING);
+        const alarmMessageSchema = this.getSchema(...SCHEMA_CODE.ALARM_MESSAGE);
+        if (this.getSchema(...SCHEMA_CODE.DOORBELL) && (doorbellRingSchema || alarmMessageSchema)) {
+            const doorbellRingStatus = doorbellRingSchema && status.find(_status => _status.code === doorbellRingSchema.code);
+            const alarmMessageStatus = alarmMessageSchema && status.find(_status => _status.code === alarmMessageSchema.code);
+            if (doorbellRingStatus && doorbellRingStatus.value.length > 1) { // Compared with '1' in order to filter value '$'
+                (0, ProgrammableSwitchEvent_1.onProgrammableSwitchEvent)(this, this.getDoorbellService(), doorbellRingStatus);
+            }
+            else if (alarmMessageStatus && alarmMessageStatus.value.length > 1) {
+                (0, ProgrammableSwitchEvent_1.onProgrammableSwitchEvent)(this, this.getDoorbellService(), alarmMessageStatus);
+            }
+        }
+        const motionSchema = this.getSchema(...SCHEMA_CODE.MOTION_DETECT);
+        if (motionSchema) {
+            const motionStatus = status.find(_status => _status.code === motionSchema.code);
+            if (motionStatus) {
+                this.onMotionDetected(motionStatus);
+            }
+        }
+    }
+    onMotionDetected(status) {
+        if (!this.initialized) {
+            return;
+        }
+        const data = Buffer.from(status.value, 'base64').toString('binary');
+        if (data.length === 0) {
+            return;
+        }
+        this.log.info('Motion event:', data);
+        const characteristic = this.getMotionService().getCharacteristic(this.Characteristic.MotionDetected);
+        characteristic.updateValue(true);
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => characteristic.updateValue(false), 30 * 1000);
+    }
+}
+exports.default = CameraAccessory;
+//# sourceMappingURL=CameraAccessory.js.map

package/dist/shared/accessories/CarbonDioxideSensorAccessory.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    CO2_STATUS: ['co2_state'],
+    CO2_LEVEL: ['co2_value'],
+};
+class CarbonDioxideSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CO2_STATUS];
+    }
+    configureServices() {
+        this.configureCarbonDioxideDetected();
+        this.configureCarbonDioxideLevel();
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.CarbonDioxideSensor)
+            || this.accessory.addService(this.Service.CarbonDioxideSensor);
+    }
+    configureCarbonDioxideDetected() {
+        const schema = this.getSchema(...SCHEMA_CODE.CO2_STATUS);
+        if (!schema) {
+            return;
+        }
+        const { CO2_LEVELS_ABNORMAL, CO2_LEVELS_NORMAL } = this.Characteristic.CarbonDioxideDetected;
+        this.mainService().getCharacteristic(this.Characteristic.CarbonDioxideDetected)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (status.value === 'alarm') ? CO2_LEVELS_ABNORMAL : CO2_LEVELS_NORMAL;
+        });
+    }
+    configureCarbonDioxideLevel() {
+        const schema = this.getSchema(...SCHEMA_CODE.CO2_LEVEL);
+        if (!schema) {
+            return;
+        }
+        const property = schema.property;
+        const multiple = Math.pow(10, property ? property.scale : 0);
+        this.mainService().getCharacteristic(this.Characteristic.CarbonDioxideLevel)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            const value = (0, util_1.limit)(status.value / multiple, 0, 100000);
+            return value;
+        });
+    }
+}
+exports.default = CarbonDioxideSensorAccessory;
+//# sourceMappingURL=CarbonDioxideSensorAccessory.js.map

package/dist/shared/accessories/CarbonMonoxideSensorAccessory.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    CO_STATUS: ['co_status', 'co_state'],
+    CO_LEVEL: ['co_value'],
+};
+class CarbonMonoxideSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CO_STATUS];
+    }
+    configureServices() {
+        this.configureCarbonMonoxideDetected();
+        this.configureCarbonMonoxideLevel();
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.CarbonMonoxideSensor)
+            || this.accessory.addService(this.Service.CarbonMonoxideSensor);
+    }
+    configureCarbonMonoxideDetected() {
+        const schema = this.getSchema(...SCHEMA_CODE.CO_STATUS);
+        if (!schema) {
+            return;
+        }
+        const { CO_LEVELS_ABNORMAL, CO_LEVELS_NORMAL } = this.Characteristic.CarbonMonoxideDetected;
+        this.mainService().getCharacteristic(this.Characteristic.CarbonMonoxideDetected)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (status.value === 'alarm' || status.value === '1') ? CO_LEVELS_ABNORMAL : CO_LEVELS_NORMAL;
+        });
+    }
+    configureCarbonMonoxideLevel() {
+        const schema = this.getSchema(...SCHEMA_CODE.CO_LEVEL);
+        if (!schema) {
+            return;
+        }
+        const property = schema.property;
+        const multiple = Math.pow(10, property ? property.scale : 0);
+        this.mainService().getCharacteristic(this.Characteristic.CarbonMonoxideLevel)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            const value = (0, util_1.limit)(status.value / multiple, 0, 100);
+            return value;
+        });
+    }
+}
+exports.default = CarbonMonoxideSensorAccessory;
+//# sourceMappingURL=CarbonMonoxideSensorAccessory.js.map

package/dist/shared/accessories/ContactSensorAccessory.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    CONTACT_STATE: ['doorcontact_state', 'switch'],
+};
+class ContaceSensor extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CONTACT_STATE];
+    }
+    configureServices() {
+        const schema = this.getSchema(...SCHEMA_CODE.CONTACT_STATE);
+        if (!schema) {
+            return;
+        }
+        const service = this.accessory.getService(this.Service.ContactSensor)
+            || this.accessory.addService(this.Service.ContactSensor);
+        const { CONTACT_NOT_DETECTED, CONTACT_DETECTED } = this.Characteristic.ContactSensorState;
+        service.getCharacteristic(this.Characteristic.ContactSensorState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? CONTACT_NOT_DETECTED : CONTACT_DETECTED;
+        });
+    }
+}
+exports.default = ContaceSensor;
+//# sourceMappingURL=ContactSensorAccessory.js.map

package/dist/shared/accessories/DehumidifierAccessory.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const CurrentRelativeHumidity_1 = require("./characteristic/CurrentRelativeHumidity");
+const RotationSpeed_1 = require("./characteristic/RotationSpeed");
+const SwingMode_1 = require("./characteristic/SwingMode");
+const LockPhysicalControls_1 = require("./characteristic/LockPhysicalControls");
+const RelativeHumidityDehumidifierThreshold_1 = require("./characteristic/RelativeHumidityDehumidifierThreshold");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    CURRENT_HUMIDITY: ['humidity_indoor'],
+    TARGET_HUMIDITY: ['dehumidify_set_value'],
+    CURRENT_TEMP: ['temp_indoor'],
+    SPEED_LEVEL: ['fan_speed_enum'],
+    SWING: ['swing'],
+    LOCK: ['child_lock'],
+};
+class DehumidifierAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE, SCHEMA_CODE.CURRENT_HUMIDITY];
+    }
+    configureServices() {
+        // Required Characteristics
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentRelativeHumidity_1.configureCurrentRelativeHumidity)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY));
+        // Optional Characteristics
+        (0, LockPhysicalControls_1.configureLockPhysicalControls)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.LOCK));
+        (0, RelativeHumidityDehumidifierThreshold_1.configureRelativeHumidityDehumidifierThreshold)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TARGET_HUMIDITY));
+        (0, RotationSpeed_1.configureRotationSpeedLevel)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.SPEED_LEVEL));
+        (0, SwingMode_1.configureSwingMode)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.SWING));
+        // Other
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.HumidifierDehumidifier)
+            || this.accessory.addService(this.Service.HumidifierDehumidifier);
+    }
+    configureCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.ACTIVE);
+        if (!schema) {
+            this.log.warn('CurrentHumidifierDehumidifierState not supported.');
+            return;
+        }
+        const { INACTIVE, DEHUMIDIFYING } = this.Characteristic.CurrentHumidifierDehumidifierState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHumidifierDehumidifierState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status?.value ? DEHUMIDIFYING : INACTIVE;
+        });
+    }
+    configureTargetState() {
+        const { DEHUMIDIFIER } = this.Characteristic.TargetHumidifierDehumidifierState;
+        const validValues = [DEHUMIDIFIER];
+        this.mainService().getCharacteristic(this.Characteristic.TargetHumidifierDehumidifierState)
+            .onGet(() => {
+            return DEHUMIDIFIER;
+        }).setProps({ validValues });
+    }
+}
+exports.default = DehumidifierAccessory;
+//# sourceMappingURL=DehumidifierAccessory.js.map

package/dist/shared/accessories/DiffuserAccessory.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const Light_1 = require("./characteristic/Light");
+const On_1 = require("./characteristic/On");
+const RotationSpeed_1 = require("./characteristic/RotationSpeed");
+const SCHEMA_CODE = {
+    ON: ['switch'],
+    SPRAY_ON: ['switch_spray'],
+    SPRAY_MODE: ['mode'],
+    SPRAY_LEVEL: ['level'],
+    LIGHT_ON: ['switch_led'],
+    LIGHT_MODE: ['work_mode'],
+    LIGHT_BRIGHT: ['bright_value', 'bright_value_v2'],
+    LIGHT_COLOR: ['colour_data', 'colour_data_hsv'],
+    SOUND_ON: ['switch_sound'],
+};
+class DiffuserAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.SPRAY_ON];
+    }
+    configureServices() {
+        // Main Switch
+        (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.ON));
+        this.configureDiffuser();
+        (0, Light_1.configureLight)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_ON), this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT), undefined, this.getSchema(...SCHEMA_CODE.LIGHT_COLOR), this.getSchema(...SCHEMA_CODE.LIGHT_MODE));
+        (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.SOUND_ON)); // Sound Switch
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.AirPurifier)
+            || this.accessory.addService(this.Service.AirPurifier);
+    }
+    configureDiffuser() {
+        const sprayOnSchema = this.getSchema(...SCHEMA_CODE.SPRAY_ON);
+        // Required Characteristics
+        (0, Active_1.configureActive)(this, this.mainService(), sprayOnSchema);
+        const { INACTIVE, PURIFYING_AIR } = this.Characteristic.CurrentAirPurifierState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentAirPurifierState)
+            .onGet(() => {
+            const status = this.getStatus(sprayOnSchema.code);
+            return status.value ? PURIFYING_AIR : INACTIVE;
+        });
+        // const { MANUAL } = this.Characteristic.TargetAirPurifierState;
+        // this.mainService().getCharacteristic(this.Characteristic.TargetAirPurifierState)
+        //   .setProps({ validValues: [MANUAL] });
+        // Optional Characteristics
+        (0, RotationSpeed_1.configureRotationSpeedLevel)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.SPRAY_LEVEL));
+    }
+}
+exports.default = DiffuserAccessory;
+//# sourceMappingURL=DiffuserAccessory.js.map

package/dist/shared/accessories/DimmerAccessory.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Name_1 = require("./characteristic/Name");
+const On_1 = require("./characteristic/On");
+const SCHEMA_CODE = {
+    ON: ['switch', 'switch_led', 'switch_1', 'switch_led_1'],
+    BRIGHTNESS: ['bright_value', 'bright_value_1'],
+};
+class DimmerAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ON, SCHEMA_CODE.BRIGHTNESS];
+    }
+    configureServices() {
+        const oldService = this.accessory.getService(this.Service.Lightbulb);
+        if (oldService && oldService?.subtype === undefined) {
+            this.platform.log.warn('Remove old service:', oldService.UUID);
+            this.accessory.removeService(oldService);
+        }
+        const schema = this.device.schema.filter((schema) => schema.code.startsWith('bright_value'));
+        for (const _schema of schema) {
+            const suffix = _schema.code.replace('bright_value', '');
+            const name = (schema.length === 1) ? this.device.name : _schema.code;
+            const service = this.accessory.getService(_schema.code)
+                || this.accessory.addService(this.Service.Lightbulb, name, _schema.code);
+            (0, Name_1.configureName)(this, service, name);
+            (0, On_1.configureOn)(this, service, this.getSchema('switch' + suffix, 'switch_led' + suffix));
+            this.configureBrightness(service, suffix);
+        }
+    }
+    configureBrightness(service, suffix) {
+        const schema = this.getSchema('bright_value' + suffix);
+        if (!schema) {
+            return;
+        }
+        const { min, max } = schema.property;
+        const range = max; // not max - min
+        const props = {
+            minValue: 0,
+            maxValue: 100,
+            minStep: 1,
+        };
+        const minStatus = this.getStatus('brightness_min' + suffix);
+        const maxStatus = this.getStatus('brightness_max' + suffix);
+        if (minStatus && maxStatus && maxStatus.value > minStatus.value) {
+            const minValue = Math.ceil((0, util_1.remap)(minStatus.value, 0, range, 0, 100));
+            const maxValue = Math.floor((0, util_1.remap)(maxStatus.value, 0, range, 0, 100));
+            props.minValue = Math.max(props.minValue, minValue);
+            props.maxValue = Math.min(props.maxValue, maxValue);
+        }
+        this.log.debug('Set props for Brightness:', props);
+        service.getCharacteristic(this.Characteristic.Brightness)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            let value = status.value;
+            value = (0, util_1.remap)(value, 0, range, 0, 100);
+            value = Math.round(value);
+            value = (0, util_1.limit)(value, props.minValue, props.maxValue);
+            return value;
+        })
+            .onSet(async (value) => {
+            this.log.debug(`Characteristic.Brightness set to: ${value}`);
+            let brightValue = value;
+            brightValue = (0, util_1.remap)(brightValue, 0, 100, 0, range);
+            brightValue = Math.round(brightValue);
+            brightValue = (0, util_1.limit)(brightValue, min, max);
+            await this.sendCommands([{ code: schema.code, value: brightValue }], true);
+        })
+            .setProps(props);
+    }
+    async onDeviceStatusUpdate(status) {
+        // brightness range updated
+        if (status.length !== this.device.status.length) {
+            for (const _status of status) {
+                if (!_status.code.startsWith('brightness_min')
+                    && !_status.code.startsWith('brightness_max')) {
+                    continue;
+                }
+                this.platform.log.warn('Brightness range updated, please restart homebridge to take effect.');
+                // TODO updating props
+                // this.platform.log.debug('Brightness range updated, resetting props...');
+                // this.configure();
+                break;
+            }
+        }
+        super.onDeviceStatusUpdate(status);
+    }
+}
+exports.default = DimmerAccessory;
+//# sourceMappingURL=DimmerAccessory.js.map

package/dist/shared/accessories/DoorbellAccessory.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const ProgrammableSwitchEvent_1 = require("./characteristic/ProgrammableSwitchEvent");
+const SCHEMA_CODE = {
+    // ALARM_MESSAGE: ['alarm_message'],
+    // ALARM_SWITCH: ['alarm_propel_switch'],
+    // VOLUME: ['doorbell_volume_value'],
+    DOORBELL_CALL: ['doorbell_call'],
+};
+class DoorbellAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.DOORBELL_CALL];
+    }
+    configureServices() {
+        this.log.warn('HomeKit Doorbell service does not work without camera anymore.');
+        this.log.warn('Downgrade to StatelessProgrammableSwitch. "Mute" and "Volume" not available.');
+        (0, ProgrammableSwitchEvent_1.configureProgrammableSwitchEvent)(this, this.getDoorbellService(), this.getSchema(...SCHEMA_CODE.DOORBELL_CALL));
+        // this.configureMute();
+        // this.configureVolume();
+    }
+    /*
+    configureMute() {
+      const schema = this.getSchema(...SCHEMA_CODE.ALARM_SWITCH);
+      if (!schema) {
+        return;
+      }
+  
+      this.getDoorbellService().getCharacteristic(this.Characteristic.Mute)
+        .onGet(() => {
+          const status = this.getStatus(schema.code)!;
+          const value = !(status.value as boolean);
+          return value;
+        })
+        .onSet(async value => {
+          const mute = !(value as boolean);
+          await this.sendCommands([{ code: schema.code, value: mute }], true);
+        });
+    }
+  
+    configureVolume() {
+      const schema = this.getSchema(...SCHEMA_CODE.VOLUME);
+      if (!schema) {
+        return;
+      }
+  
+      const property = schema.property as TuyaDeviceSchemaIntegerProperty;
+      const multiple = Math.pow(10, property.scale);
+      const props = {
+        minValue: property.min / multiple,
+        maxValue: property.max / multiple,
+        minStep: Math.max(1, property.step / multiple),
+      };
+      this.getDoorbellService().getCharacteristic(this.Characteristic.Volume)
+        .onGet(() => {
+          const status = this.getStatus(schema.code)!;
+          const value = status.value as number / multiple;
+          return value;
+        })
+        .onSet(async value => {
+          const volume = (value as number) * multiple;
+          await this.sendCommands([{ code: schema.code, value: volume }], true);
+        })
+        .setProps(props);
+    }
+  
+    getDoorbellService() {
+      return this.accessory.getService(this.Service.Doorbell)
+        || this.accessory.addService(this.Service.Doorbell);
+    }
+    */
+    getDoorbellService() {
+        return this.accessory.getService(this.Service.StatelessProgrammableSwitch)
+            || this.accessory.addService(this.Service.StatelessProgrammableSwitch);
+    }
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        const doorbellCallSchema = this.getSchema(...SCHEMA_CODE.DOORBELL_CALL);
+        if (doorbellCallSchema) {
+            const doorbellCallStatus = status.find(_status => _status.code === doorbellCallSchema.code);
+            if (doorbellCallStatus) {
+                (0, ProgrammableSwitchEvent_1.onProgrammableSwitchEvent)(this, this.getDoorbellService(), doorbellCallStatus);
+            }
+        }
+    }
+}
+exports.default = DoorbellAccessory;
+//# sourceMappingURL=DoorbellAccessory.js.map