homebridge-ttlock-accesscode 1.0.1 → 2.0.0-beta.1

package/dist/platform.js

@@ -1,336 +1,499 @@
 import { EventEmitter } from 'node:events';
+import create from './devices/create.js';
+import DeviceManager from './devices/deviceManager.js';
 import { parseConfig } from './config.js';
-import { TTLockHomeKitDevice } from './homekitDevice.js';
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
-import { lookup, lookupCharacteristicNameByUUID, isObjectLike } from './utils.js';
+import { TaskQueue } from './taskQueue.js';
+import { deferAndCombine, isObjectLike, loadPackageConfig, lookup, lookupCharacteristicNameByUUID, satisfiesVersion, } from './utils.js';
 import { TTLockApi } from './api/ttlockApi.js';
-export class TTLockAccessCodePlatform {
+import { UsageTracker } from './api/usageTracker.js';
+import { deviceEventEmitter } from './devices/deviceManager.js';
+let packageConfig;
+export default class TTLockAccessCodePlatform {
     log;
     api;
-    homekitDevicesById = new Map();
+    Characteristic;
     configuredAccessories = new Map();
     offlineAccessories = new Map();
+    Service;
     config;
+    deviceManager;
     isShuttingDown = false;
-    ongoingTasks = [];
-    periodicDeviceDiscoveryEmitter = new EventEmitter();
     periodicDeviceDiscovering = false;
+    periodicDeviceDiscoveryEmitter;
     ttLockApi;
+    usageTracker;
+    taskQueue;
+    homekitDevicesById = new Map();
+    deviceDiscoveredHandler;
+    platformInitialization;
     constructor(log, config, api) {
         this.log = log;
         this.api = api;
+        this.Service = this.api.hap.Service;
+        this.Characteristic = this.api.hap.Characteristic;
         this.config = parseConfig(config);
+        this.periodicDeviceDiscoveryEmitter = new EventEmitter();
+        this.taskQueue = new TaskQueue(this.log, () => this.isShuttingDown);
+        this.periodicDeviceDiscoveryEmitter.setMaxListeners(255);
+        this.setupDeviceEventEmitter('firstDiscovery');
+        this.platformInitialization = this.initializePlatform();
         this.api.on('didFinishLaunching', async () => {
-            this.log.info('TTLockAccessCode Platform finished launching');
+            this.log.debug('TTLockAccessCode Platform finished launching');
+            await this.platformInitialization;
+            await this.didFinishLaunching();
+            if (this.offlineAccessories.size > 0) {
+                this.log.debug('Unregistering offline accessories');
+                this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, Array.from(this.offlineAccessories.values()));
+                this.offlineAccessories.clear();
+            }
+        });
+        this.api.on('shutdown', async () => {
+            this.log.debug('TTLockAccessCode Platform shutting down');
+            if (!this.isShuttingDown) {
+                this.isShuttingDown = true;
+            }
+            this.log.debug('Stopping all polling tasks');
+            for (const device of this.homekitDevicesById.values()) {
+                await device.stopPolling();
+            }
+            this.log.debug('Waiting for tasks to complete');
             try {
-                await this.createAndAuthenticateApi();
-                await this.discoverDevices();
-                this.log.debug('Setting up periodic device discovery');
-                setInterval(async () => {
-                    await this.periodicDeviceDiscovery();
-                }, this.config.discoveryOptions.discoveryPollingInterval);
-                this.log.debug('Periodic device discovery setup completed');
-                if (this.offlineAccessories.size > 0) {
-                    this.log.debug('Unregistering offline accessories');
-                    this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, Array.from(this.offlineAccessories.values()));
-                    this.offlineAccessories.clear();
-                }
+                await this.taskQueue.waitForEmptyQueue();
             }
             catch (error) {
-                this.log.error('An error occurred during startup:', error);
+                this.log.error('Error while waiting for task queue to empty during shutdown:', error);
             }
+            this.stopTTLockApi();
         });
-        this.api.on('shutdown', async () => {
-            this.log.debug('TTLockAccessCode platform shutting down');
-            this.isShuttingDown = true;
-            await Promise.all(this.ongoingTasks);
-            this.log.debug('All ongoing tasks completed. Platform is now shutting down.');
-        });
-        this.periodicDeviceDiscoveryEmitter.setMaxListeners(150);
     }
-    async createAndAuthenticateApi() {
-        this.log.debug('Creating and authenticating TTLock API');
-        try {
-            this.ttLockApi = new TTLockApi(this.log, this.config.clientId, this.config.clientSecret);
-            await this.ttLockApi.authenticate(this.config.username, this.config.password);
+    setupDeviceEventEmitter(mode, discoveredDeviceIds) {
+        if (this.deviceDiscoveredHandler) {
+            deviceEventEmitter.off('deviceDiscovered', this.deviceDiscoveredHandler);
         }
-        catch (error) {
-            this.log.error('Failed to authenticate with TTLock API:', error);
+        this.log.debug(`Setting up device event emitter: ${mode}`);
+        if (mode === 'periodicDiscovery' && discoveredDeviceIds) {
+            this.deviceDiscoveredHandler = async (device) => {
+                this.log.debug(`Device discovered during periodic discovery: ${device.sys_info.device_id}`);
+                discoveredDeviceIds.add(device.sys_info.device_id);
+                this.log.debug(`Added device ID to discoveredDeviceIds: ${device.sys_info.device_id}`);
+                await this.processDevice(device);
+            };
         }
-    }
-    async discoverDevices() {
-        this.log.debug('Discovering devices');
-        if (!this.ttLockApi) {
-            this.log.error('TTLock API not initialized');
-            return;
+        else {
+            this.deviceDiscoveredHandler = async (device) => {
+                this.log.debug(`Device discovered during initial discovery: ${device.sys_info.device_id}`);
+                await this.processDevice(device);
+            };
         }
+        deviceEventEmitter.on('deviceDiscovered', this.deviceDiscoveredHandler);
+    }
+    async initializePlatform() {
+        packageConfig = await loadPackageConfig(this.log);
+        this.logInitializationDetails();
+        await this.verifyEnvironment();
+    }
+    logInitializationDetails() {
+        this.log.info(`${packageConfig.name} v${packageConfig.version}, node ${process.version}, ` +
+            `homebridge v${this.api.serverVersion}, api v${this.api.version} Initializing...`);
+    }
+    async verifyEnvironment() {
+        this.log.debug('Verifying environment');
         try {
-            const locks = await this.ttLockApi.getLocks();
-            const detailedLocks = await this.getDetailedLocks(locks);
-            for (const detailedLock of detailedLocks) {
-                this.foundDevice(detailedLock);
+            this.log.debug('Checking Node.js version');
+            if (!satisfiesVersion(process.version, packageConfig.engines.node)) {
+                this.log.error(`Error: not using minimum node version ${packageConfig.engines.node}`);
+            }
+            else {
+                this.log.debug(`Node.js version ${process.version} satisfies the requirement ${packageConfig.engines.node}`);
+            }
+            this.log.debug('Checking Homebridge version');
+            if (this.api.versionGreaterOrEqual &&
+                !(this.api.versionGreaterOrEqual('1.11.0') ||
+                    this.api.versionGreaterOrEqual('2.0.0'))) {
+                throw new Error(`homebridge-ttlock-accesscode requires Homebridge ^1.11.0 || ^2.0.0-beta.0. Currently running: ${this.api.serverVersion}`);
+            }
+            else {
+                this.log.debug(`Homebridge version ${this.api.serverVersion} satisfies the requirement ^1.11.0 || ^2.0.0-beta.0`);
             }
-            this.periodicDeviceDiscoveryEmitter.setMaxListeners(detailedLocks.length + 10);
-            const maxListenerCount = this.periodicDeviceDiscoveryEmitter.getMaxListeners();
-            this.log.debug('periodicDeviceDiscoveryEmitter max listener count:', maxListenerCount);
         }
         catch (error) {
-            this.log.error('Error discovering devices:', error);
+            this.log.error('Error verifying environment:', error);
+            throw error;
         }
     }
-    async getDetailedLocks(locks) {
-        if (!this.ttLockApi) {
-            return Promise.reject(new Error('TTLock API not initialized'));
-        }
-        const detailedLocks = [];
-        for (const lock of locks) {
-            this.log.debug(`Processing lock: ${lock.lockId}`);
-            const lockDetails = await this.ttLockApi.getLockDetails(lock.lockId);
-            const lockState = await this.ttLockApi.getLockState(lock.lockId);
-            const lockBattery = await this.ttLockApi.getBatteryLevel(lock.lockId);
-            const lockPassCodes = await this.ttLockApi.getPasscodes(lock.lockId);
-            const detailedLock = await this.ttLockApi.mapToLock(lockDetails, lockState, lockBattery, lockPassCodes);
-            this.log.debug(`Detailed lock: ${JSON.stringify(detailedLock)}`);
-            detailedLocks.push(detailedLock);
-        }
-        return detailedLocks;
-    }
-    foundDevice(device) {
-        const { alias: deviceAlias, id: deviceId } = device;
-        if (!deviceId) {
-            this.log.error('Missing deviceId:', deviceAlias);
-            return;
+    async didFinishLaunching() {
+        this.log.debug('Finished launching');
+        try {
+            await this.startTTLockApi();
+            this.log.debug('Initializing DeviceManager');
+            this.deviceManager = new DeviceManager(this);
+            this.log.debug('DeviceManager initialized');
+            await this.discoverDevices();
+            this.log.debug('Device discovery completed');
+            const discoveredDeviceIds = new Set();
+            this.setupPeriodicDiscovery(discoveredDeviceIds);
         }
-        if (this.homekitDevicesById.has(deviceId)) {
-            this.log.info(`HomeKit device already added: [${deviceAlias}] [${deviceId}]`);
-            return;
+        catch (error) {
+            this.log.error('An error occurred during startup:', error);
         }
-        this.log.info(`Adding HomeKit device: [${deviceAlias}] [${deviceId}]`);
-        const homekitDevice = new TTLockHomeKitDevice(this, device);
-        if (homekitDevice) {
-            this.homekitDevicesById.set(deviceId, homekitDevice);
-            this.log.debug(`HomeKit device [${deviceAlias}] [${deviceId}] successfully added`);
+    }
+    setupPeriodicDiscovery(discoveredDeviceIds) {
+        this.log.debug('Setting up periodic device discovery');
+        this.setupDeviceEventEmitter('periodicDiscovery', discoveredDeviceIds);
+        const discoveryTask = async () => {
+            await this.periodicDeviceDiscovery(discoveredDeviceIds);
+        };
+        const deferredDiscoveryTask = deferAndCombine(discoveryTask, this.config.advancedOptions.waitTimeUpdate);
+        setInterval(() => {
+            try {
+                this.taskQueue.addTask(deferredDiscoveryTask);
+            }
+            catch (error) {
+                this.log.error('Error scheduling periodic device discovery:', error);
+            }
+        }, this.config.discoveryOptions.discoveryPollingInterval);
+        this.log.debug('Periodic device discovery setup completed');
+    }
+    async discoverDevices() {
+        try {
+            if (this.deviceManager) {
+                try {
+                    const deviceCount = this.configuredAccessories.size || 0;
+                    const callsForDiscovery = 1 + (2 * deviceCount);
+                    if (this.usageTracker) {
+                        const reserved = await this.usageTracker.beginBatch(callsForDiscovery, 'initialDiscovery');
+                        if (!reserved) {
+                            this.log.info('Skipping initial device discovery due to API usage budget');
+                            return;
+                        }
+                    }
+                }
+                catch (error) {
+                    this.log.debug('Error reserving budget for initial discovery', error);
+                }
+                await this.deviceManager.discoverDevices();
+            }
         }
-        else {
-            this.log.error(`Failed to add HomeKit device for: [${deviceAlias}] [${deviceId}]`);
+        catch (error) {
+            this.log.error('Error during discoverDevices:', error);
         }
     }
-    async periodicDeviceDiscovery() {
+    async periodicDeviceDiscovery(discoveredDeviceIds) {
+        this.log.debug('Starting periodic device discovery');
         if (this.periodicDeviceDiscovering) {
-            this.log.debug('Periodic device discovery is already in progress');
+            this.log.debug('Periodic device discovery already in progress');
             return;
         }
-        if (!this.ttLockApi) {
-            this.log.error('TTLock API not initialized');
+        if (this.isShuttingDown) {
+            this.log.debug('Platform is shutting down, skipping periodic device discovery');
             return;
         }
         this.periodicDeviceDiscovering = true;
+        discoveredDeviceIds.clear();
+        this.log.debug('Cleared discoveredDeviceIds set before discovery.');
         try {
-            this.log.debug('Starting periodic device discovery');
-            const locks = await this.ttLockApi.getLocks();
-            const detailedLocks = await this.getDetailedLocks(locks);
-            const now = new Date();
-            const offlineInterval = this.config.discoveryOptions.offlineInterval;
-            this.configuredAccessories.forEach((platformAccessory, uuid) => {
-                const deviceId = platformAccessory.context.id;
-                if (deviceId) {
-                    const device = this.findDiscoveredDevice(detailedLocks, platformAccessory);
-                    if (device) {
-                        this.updateAccessoryDeviceStatus(platformAccessory, device, now);
-                        this.updateOrCreateHomeKitDevice(deviceId, device);
-                    }
-                    else {
-                        this.updateAccessoryStatus(platformAccessory);
-                        this.handleOfflineAccessory(platformAccessory, uuid, now, offlineInterval);
+            if (this.deviceManager) {
+                try {
+                    const deviceCount = this.configuredAccessories.size || 0;
+                    const callsForDiscovery = 1 + (2 * deviceCount);
+                    if (this.usageTracker) {
+                        const reserved = await this.usageTracker.beginBatch(callsForDiscovery, 'periodicDiscovery');
+                        if (!reserved) {
+                            this.log.info('Skipping periodic device discovery due to API usage budget');
+                            return;
+                        }
                     }
                 }
-            });
+                catch (error) {
+                    this.log.debug('Error reserving budget for periodic discovery', error);
+                }
+                await this.deviceManager.discoverDevices();
+            }
+        }
+        catch (error) {
+            this.log.error('Error during periodic device discovery:', error);
         }
         finally {
+            this.handleOfflineDevices(discoveredDeviceIds);
             this.periodicDeviceDiscovering = false;
-            this.log.debug('Ending periodic device discovery');
             this.periodicDeviceDiscoveryEmitter.emit('periodicDeviceDiscoveryComplete');
+            this.log.debug('Finished periodic device discovery');
         }
     }
-    findDiscoveredDevice(discoveredDevices, platformAccessory) {
-        this.log.debug(`Finding discovered device with Platform Accessory ${platformAccessory.displayName}`);
+    async processDevice(device) {
+        this.log.debug(`Processing device: ${device.sys_info.device_id}`);
         try {
-            const device = discoveredDevices.find(device => device.id === platformAccessory.context.id);
-            if (device) {
-                this.log.debug(`Discovered device ${device.alias}`);
+            const now = new Date();
+            device.last_seen = now;
+            device.offline = false;
+            const accessory = this.findPlatformAccessory(device.sys_info.device_id);
+            if (accessory) {
+                await this.updateExistingDevice(accessory, device, now);
             }
             else {
-                this.log.debug(`No discovered device found with Platform Accessory ${platformAccessory.displayName}`);
+                await this.addNewDevice(device);
             }
-            return device;
         }
         catch (error) {
-            this.log.error(`Error finding discovered device with Platform Accessory ${platformAccessory.displayName}: ${error}`);
-            return undefined;
+            this.log.error(`Error processing device [${device.sys_info.device_id}]:`, error);
         }
     }
-    updateAccessoryDeviceStatus(platformAccessory, device, now) {
-        this.log.debug(`Updating Platform Accessory and HomeKit device statuses for ${platformAccessory.displayName}`);
-        try {
-            this.log.debug(`Setting HomeKit device ${device.alias} last seen time to now and marking as online`);
-            device.lastSeen = now;
-            device.offline = false;
-            this.log.debug(`Setting Platform Accessory ${platformAccessory.displayName} last seen time to now and marking as online`);
-            platformAccessory.context.lastSeen = now;
-            platformAccessory.context.offline = false;
-            this.log.debug(`Updating Platform Accessory ${platformAccessory.displayName}`);
-            this.api.updatePlatformAccessories([platformAccessory]);
-            this.log.debug(`Platform Accessory and HomeKit device statuses for ${platformAccessory.displayName} updated successfully`);
+    handleOfflineDevices(discoveredDeviceIds) {
+        const now = new Date();
+        this.configuredAccessories.forEach((accessory, uuid) => {
+            const deviceId = accessory.context.deviceId;
+            if (!deviceId) {
+                this.log.warn(`Accessory [${accessory.displayName}] is missing a deviceId.`);
+                return;
+            }
+            if (discoveredDeviceIds.has(deviceId)) {
+                this.log.debug(`Accessory [${accessory.displayName}] was discovered and is online.`);
+                this.updateAccessoryStatus(accessory, now, false);
+            }
+            else {
+                this.handleOfflineAccessory(accessory, uuid, now);
+            }
+        });
+    }
+    handleOfflineAccessory(accessory, uuid, now) {
+        const timeSinceLastSeen = now.getTime() - new Date(accessory.context.lastSeen || 0).getTime();
+        const offlineInterval = this.config.discoveryOptions.offlineInterval;
+        if (timeSinceLastSeen > offlineInterval) {
+            this.log.info(`Accessory [${accessory.displayName}] is offline and outside the offline interval. Removing.`);
+            this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+            this.configuredAccessories.delete(uuid);
         }
-        catch (error) {
-            this.log.error(`Error updating Platform Accessory and HomeKit device statuses for ${platformAccessory.displayName}: ${error}`);
+        else if (!accessory.context.offline) {
+            this.log.debug(`Accessory [${accessory.displayName}] is offline but within the offline interval.`);
+            this.updateAccessoryStatus(accessory, accessory.context.lastSeen || now, true);
         }
     }
-    updateOrCreateHomeKitDevice(deviceId, device) {
-        this.log.debug(`Updating or creating HomeKit device ${device.alias}`);
-        try {
-            if (this.homekitDevicesById.has(deviceId)) {
-                this.log.debug(`HomeKit device ${device.alias} already exists.`);
-                const existingDevice = this.homekitDevicesById.get(deviceId);
-                if (existingDevice) {
-                    if (!existingDevice.isUpdating) {
-                        if (existingDevice.lock.offline === true && device.offline === false) {
-                            this.log.debug(`HomeKit device ${device.alias} was offline and is now online. ` +
-                                'Updating device and starting polling.');
-                            existingDevice.lock = device;
-                            existingDevice.startPolling();
-                        }
-                        else {
-                            this.log.debug(`Updating existing HomeKit device ${device.alias}`);
-                            existingDevice.lock = device;
-                        }
-                    }
-                    else {
-                        this.log.debug(`HomeKit device ${device.alias} is currently updating. Skipping update.`);
-                    }
+    findPlatformAccessory(deviceId) {
+        for (const accessory of this.configuredAccessories.values()) {
+            if (accessory.context.deviceId === deviceId) {
+                return accessory;
+            }
+        }
+        return undefined;
+    }
+    async updateExistingDevice(accessory, device, now) {
+        this.log.debug(`Device [${device.sys_info.device_id}] is already configured, updating status.`);
+        this.updateAccessoryStatus(accessory, now, false);
+        const existingDevice = this.homekitDevicesById.get(device.sys_info.device_id);
+        if (existingDevice) {
+            if (!existingDevice.isUpdating) {
+                if (existingDevice.ttlockDevice.offline && !device.offline) {
+                    this.log.debug(`Device [${device.sys_info.device_id}] was offline and is now online. Updating and starting polling.`);
+                    existingDevice.ttlockDevice = device;
+                    existingDevice.updateAfterPeriodicDiscovery();
+                    existingDevice.startPolling();
                 }
                 else {
-                    this.log.error(`Failed to retrieve existing HomeKit device ${device.alias} from homekitDevicesById.`);
+                    this.log.debug(`Updating existing HomeKit device [${device.sys_info.device_id}].`);
+                    existingDevice.ttlockDevice = device;
+                    existingDevice.updateAfterPeriodicDiscovery();
                 }
             }
             else {
-                this.log.debug(`HomeKit device ${device.alias} does not exist.`);
-                this.foundDevice(device);
+                this.log.debug(`HomeKit device [${device.sys_info.device_id}] is currently updating. Skipping update.`);
             }
         }
-        catch (error) {
-            this.log.error(`Error updating or creating HomeKit device ${device.alias}: ${error}`);
+        else {
+            await this.addNewDevice(device);
         }
     }
-    updateAccessoryStatus(platformAccessory) {
+    async addNewDevice(device) {
+        this.log.debug(`New device [${device.sys_info.device_id}] found, adding to HomeKit.`);
+        await this.foundDevice(device);
+    }
+    updateAccessoryStatus(accessory, lastSeen, offline) {
+        accessory.context.lastSeen = lastSeen;
+        accessory.context.offline = offline;
+    }
+    async startTTLockApi() {
+        this.log.debug('Starting TTLock API');
         try {
-            this.log.debug(`Setting Platform Accessory ${platformAccessory.displayName} offline status to true`);
-            platformAccessory.context.offline = true;
-            this.api.updatePlatformAccessories([platformAccessory]);
-            this.log.debug(`Platform Accessory ${platformAccessory.displayName} status updated successfully`);
+            await this.createAndAuthenticateApi();
+            this.log.debug('TTLock API process started successfully');
         }
         catch (error) {
-            this.log.error(`Error updating Platform Accessory ${platformAccessory.displayName} status: ${error}`);
+            this.log.error(`Error starting TTLock API process: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+    stopTTLockApi() {
+        this.log.debug('Stopping TTLock API');
+        if (this.ttLockApi) {
+            this.log.debug('TTLock API process found, attempting to kill the process');
+            this.ttLockApi = undefined;
+            this.log.debug('TTLock API process successfully killed');
+        }
+        else {
+            this.log.debug('No TTLock API process found to stop');
         }
     }
-    handleOfflineAccessory(platformAccessory, uuid, now, offlineInterval) {
-        this.log.debug(`Handling offline Platform Accessory ${platformAccessory.displayName}`);
+    async createAndAuthenticateApi() {
+        this.log.debug('Creating and authenticating TTLock API...');
         try {
-            const homekitDevice = this.homekitDevicesById.get(platformAccessory.context.deviceId);
-            if (homekitDevice) {
-                const timeSinceLastSeen = now.getTime() - new Date(homekitDevice.lock.lastSeen).getTime();
-                this.log.debug(`Time since last seen for Platform Accessory ${platformAccessory.displayName}: ${timeSinceLastSeen}ms, ` +
-                    `offline interval: ${offlineInterval}ms`);
-                if (timeSinceLastSeen < offlineInterval) {
-                    this.log.debug(`Platform Accessory ${platformAccessory.displayName} is offline and within offline interval.`);
-                    homekitDevice.lock.offline = true;
-                }
-                else if (timeSinceLastSeen > offlineInterval) {
-                    this.log.info(`Platform Accessory ${platformAccessory.displayName} is offline and outside the offline interval, removing.`);
-                    this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [platformAccessory]);
-                    this.configuredAccessories.delete(uuid);
-                    this.log.debug(`Platform Accessory [${platformAccessory.displayName}] removed successfully.`);
-                }
+            this.log.debug('Initializing UsageTracker...');
+            this.usageTracker = new UsageTracker(this.api, this.log, this.config.totalApiCallsPerMonth);
+            await this.usageTracker.init();
+            this.log.debug('UsageTracker initialized');
+            this.usageTracker.on('tierChanged', () => {
+                this.log.info('API usage tier changed — recalculating polling intervals...');
+                void this.reschedulePolling();
+            });
+        }
+        catch (err) {
+            this.log.error('Failed to initialize usage tracker', err);
+            this.usageTracker = undefined;
+        }
+        this.log.debug('Initializing TTLockApi...');
+        this.ttLockApi = new TTLockApi(this.log, this.config.clientId, this.config.clientSecret, this.usageTracker);
+        await this.ttLockApi.authenticate(this.config.username, this.config.password);
+    }
+    computeEffectivePollingInterval(deviceCount, userIntervalMs) {
+        if (!this.usageTracker) {
+            return userIntervalMs;
+        }
+        const usage = this.usageTracker.getUsage();
+        const daysRemaining = usage.daysRemaining ?? usage.daysInMonth;
+        const remainingDailyAllowance = (usage.remainingDailyAllowance !== undefined)
+            ? usage.remainingDailyAllowance
+            : Math.floor((usage.totalAllowed - usage.used) / Math.max(1, daysRemaining));
+        const pollingBudgetPerDay = Math.floor(remainingDailyAllowance * 0.8);
+        const estimatedCallsPerPoll = Math.max(1, deviceCount * 2);
+        const maxPollsPerDay = Math.max(1, Math.floor(pollingBudgetPerDay / estimatedCallsPerPoll));
+        const basePollingIntervalSec = Math.max(1, Math.floor(86400 / maxPollsPerDay));
+        const remainingFraction = usage.totalAllowed === 0 ? 0 : usage.remaining / usage.totalAllowed;
+        let multiplier = 1.0;
+        if (remainingFraction < 0.05) {
+            multiplier = 8.0;
+        }
+        else if (remainingFraction < 0.10) {
+            multiplier = 4.0;
+        }
+        else if (remainingFraction < 0.20) {
+            multiplier = 2.0;
+        }
+        else if (remainingFraction < 0.50) {
+            multiplier = 1.5;
+        }
+        const minPollSec = 30;
+        const maxPollSec = 3600;
+        const finalSec = Math.min(Math.max(basePollingIntervalSec * multiplier, minPollSec), maxPollSec);
+        const finalMs = Math.floor(finalSec * 1000);
+        return Math.max(userIntervalMs, finalMs);
+    }
+    async reschedulePolling() {
+        this.log.debug('Rescheduling polling for all devices');
+        for (const device of this.homekitDevicesById.values()) {
+            try {
+                await device.startPolling();
             }
-            else if (platformAccessory.context.offline === true) {
-                const timeSinceLastSeen = now.getTime() - new Date(platformAccessory.context.lastSeen).getTime();
-                this.log.debug(`Time since last seen for Platform Accessory ${platformAccessory.displayName}: ${timeSinceLastSeen}ms, ` +
-                    `offline interval: ${offlineInterval}ms`);
-                if (timeSinceLastSeen < offlineInterval) {
-                    this.log.debug(`Platform Accessory [${platformAccessory.displayName}] is offline and within offline interval.`);
-                    this.updateAccessoryStatus(platformAccessory);
-                }
-                else if (timeSinceLastSeen > offlineInterval) {
-                    this.log.info(`Platform Accessory ${platformAccessory.displayName} is offline and outside the offline interval, removing.`);
-                    this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [platformAccessory]);
-                    this.configuredAccessories.delete(uuid);
-                    this.log.debug(`Platform Accessory [${platformAccessory.displayName}] removed successfully.`);
-                }
+            catch (err) {
+                this.log.debug('Error rescheduling polling for device', err);
             }
         }
-        catch (error) {
-            this.log.error(`Error handling offline Platform Accessory ${platformAccessory.displayName}: ${error}`);
-        }
     }
-    registerPlatformAccessory(platformAccessory) {
-        this.log.debug('Registering platform platformAccessory:', platformAccessory.displayName);
-        if (!this.configuredAccessories.has(platformAccessory.UUID)) {
-            this.log.debug(`Platform Accessory ${platformAccessory.displayName} is not in configuredAccessories, adding it.`);
-            this.configuredAccessories.set(platformAccessory.UUID, platformAccessory);
+    lsc(serviceOrCharacteristic, characteristic) {
+        const serviceName = serviceOrCharacteristic instanceof this.api.hap.Service
+            ? this.getServiceName(serviceOrCharacteristic)
+            : undefined;
+        const characteristicName = characteristic instanceof this.api.hap.Characteristic
+            ? this.getCharacteristicName(characteristic)
+            : serviceOrCharacteristic instanceof this.api.hap.Characteristic || 'UUID' in serviceOrCharacteristic
+                ? this.getCharacteristicName(serviceOrCharacteristic)
+                : undefined;
+        const result = `[${serviceName ? serviceName : ''}` +
+            `${serviceName && characteristicName ? '.' : ''}` +
+            `${characteristicName ? characteristicName : ''}]`;
+        return result;
+    }
+    getServiceName(service) {
+        const serviceName = lookup(this.api.hap.Service, (objectProp, value) => isObjectLike(objectProp) && 'UUID' in objectProp && objectProp.UUID === value, service.UUID);
+        return serviceName;
+    }
+    getCharacteristicName(characteristic) {
+        const name = characteristic.name;
+        const displayName = characteristic.displayName;
+        const lookupName = lookupCharacteristicNameByUUID(this.api.hap.Characteristic, characteristic.UUID);
+        return name ?? displayName ?? lookupName;
+    }
+    registerPlatformAccessory(accessory) {
+        this.log.debug('Registering platform accessory:', accessory.displayName);
+        if (!this.configuredAccessories.has(accessory.UUID)) {
+            this.log.debug(`Platform Accessory ${accessory.displayName} is not in configuredAccessories, adding it.`);
+            this.configuredAccessories.set(accessory.UUID, accessory);
         }
         else {
-            this.log.debug(`Platform Accessory ${platformAccessory.displayName} is already in configuredAccessories.`);
+            this.log.debug(`Platform Accessory ${accessory.displayName} is already in configuredAccessories.`);
         }
-        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [platformAccessory]);
-        this.log.debug(`Platform Accessory ${platformAccessory.displayName} registered with Homebridge.`);
+        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+        this.log.debug(`Platform Accessory ${accessory.displayName} registered with Homebridge.`);
     }
-    configureAccessory(platformAccessory) {
-        this.log.debug(`Configuring Platform Accessory: [${platformAccessory.displayName}] UUID: ${platformAccessory.UUID}`);
-        if (!platformAccessory.context.lastSeen && !platformAccessory.context.offline) {
-            this.log.debug(`Setting initial lastSeen and offline status for Platform Accessory: [${platformAccessory.displayName}]`);
-            platformAccessory.context.lastSeen = new Date();
-            platformAccessory.context.offline = false;
-        }
-        if (platformAccessory.context.lastSeen) {
+    configureAccessory(accessory) {
+        this.log.debug(`Configuring Platform Accessory: [${accessory.displayName}] UUID: ${accessory.UUID}`);
+        if (!accessory.context.lastSeen && !accessory.context.offline) {
+            this.log.debug(`Setting initial lastSeen and offline status for Platform Accessory: [${accessory.displayName}]`);
+            accessory.context.lastSeen = new Date();
+            accessory.context.offline = false;
+        }
+        if (accessory.context.lastSeen) {
             const now = new Date();
-            const timeSinceLastSeen = now.getTime() - new Date(platformAccessory.context.lastSeen).getTime();
+            const timeSinceLastSeen = now.getTime() - new Date(accessory.context.lastSeen).getTime();
             const offlineInterval = this.config.discoveryOptions.offlineInterval;
-            this.log.debug(`Platform Accessory [${platformAccessory.displayName}] last seen ${timeSinceLastSeen}ms ago, ` +
-                `offline interval is ${offlineInterval}ms, offline status: ${platformAccessory.context.offline}`);
-            if (timeSinceLastSeen > offlineInterval && platformAccessory.context.offline === true) {
-                this.log.info(`Platform Accessory [${platformAccessory.displayName}] is offline and outside the offline interval, ` +
+            this.log.debug(`Platform Accessory [${accessory.displayName}] last seen ${timeSinceLastSeen}ms ago, ` +
+                `offline interval is ${offlineInterval}ms, offline status: ${accessory.context.offline}`);
+            if (timeSinceLastSeen > offlineInterval && accessory.context.offline === true) {
+                this.log.info(`Platform Accessory [${accessory.displayName}] is offline and outside the offline interval, ` +
                     'moving to offlineAccessories');
-                this.configuredAccessories.delete(platformAccessory.UUID);
-                this.offlineAccessories.set(platformAccessory.UUID, platformAccessory);
+                this.configuredAccessories.delete(accessory.UUID);
+                this.offlineAccessories.set(accessory.UUID, accessory);
                 return;
             }
-            else if (timeSinceLastSeen < offlineInterval && platformAccessory.context.offline === true) {
-                this.log.debug(`Platform Accessory [${platformAccessory.displayName}] is offline and within offline interval.`);
+            else if (timeSinceLastSeen < offlineInterval && accessory.context.offline === true) {
+                this.log.debug(`Platform Accessory [${accessory.displayName}] is offline and within offline interval.`);
             }
-            else if (platformAccessory.context.offline === false) {
-                this.log.debug(`Platform Accessory [${platformAccessory.displayName}] is online, updating lastSeen time.`);
-                platformAccessory.context.lastSeen = now;
-                this.api.updatePlatformAccessories([platformAccessory]);
+            else if (accessory.context.offline === false) {
+                this.log.debug(`Platform Accessory [${accessory.displayName}] is online, updating lastSeen time.`);
+                this.updateAccessoryStatus(accessory, now, false);
             }
         }
-        if (!this.configuredAccessories.has(platformAccessory.UUID)) {
-            this.log.debug(`Platform Accessory [${platformAccessory.displayName}] with UUID ` +
-                `[${platformAccessory.UUID}] is not in configuredAccessories, adding it.`);
-            this.configuredAccessories.set(platformAccessory.UUID, platformAccessory);
+        if (!this.configuredAccessories.has(accessory.UUID)) {
+            this.log.debug(`Platform Accessory [${accessory.displayName}] with UUID [${accessory.UUID}] ` +
+                'is not in configuredAccessories, adding it.');
+            this.configuredAccessories.set(accessory.UUID, accessory);
         }
         else {
-            this.log.debug(`Platform Accessory [${platformAccessory.displayName}] with UUID [${platformAccessory.UUID}] is already in configuredAccessories.`);
+            this.log.debug(`Platform Accessory [${accessory.displayName}] with UUID ` +
+                `[${accessory.UUID}] is already in configuredAccessories.`);
         }
     }
-    getServiceName(service) {
-        const serviceName = lookup(this.api.hap.Service, (thisKeyValue, value) => isObjectLike(thisKeyValue) && 'UUID' in thisKeyValue && thisKeyValue.UUID === value, service.UUID);
-        return serviceName;
+    async foundDevice(device) {
+        const { sys_info: { alias: deviceAlias, device_id: deviceId } } = device;
+        if (!deviceId) {
+            this.log.error('Missing deviceId:', deviceAlias);
+            return;
+        }
+        if (this.homekitDevicesById.has(deviceId)) {
+            this.log.info(`HomeKit device already added: [${deviceAlias}] [${deviceId}]`);
+            return;
+        }
+        this.log.info(`Adding HomeKit device: [${deviceAlias}] [${deviceId}]`);
+        const homekitDevice = await this.createHomeKitDevice(device);
+        if (homekitDevice) {
+            this.homekitDevicesById.set(deviceId, homekitDevice);
+            this.log.debug(`HomeKit device [${deviceAlias}] [${deviceId}] successfully added`);
+        }
+        else {
+            this.log.error(`Failed to add HomeKit device for: [${deviceAlias}] [${deviceId}]`);
+        }
     }
-    getCharacteristicName(characteristic) {
-        const name = characteristic.name;
-        const displayName = characteristic.displayName;
-        const lookupName = lookupCharacteristicNameByUUID(this.api.hap.Characteristic, characteristic.UUID);
-        return name ?? displayName ?? lookupName;
+    async createHomeKitDevice(ttlockDevice) {
+        this.log.debug('Creating HomeKit device for:', ttlockDevice.sys_info);
+        return await create(this, ttlockDevice);
     }
 }
 //# sourceMappingURL=platform.js.map