@switchbot/homebridge-switchbot 5.0.0-beta.3 → 5.0.0-beta.30

package/src/irdevice/irdevice.ts

@@ -276,69 +276,108 @@ export abstract class irdeviceBase {
   /**
    * Logging for Device
    */
-  async infoLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.info(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  infoLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    // Delegate to a single helper that prefers platform-provided loggers.
+    this.logWith('info', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async successLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.success(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  successLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('success', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugSuccessLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.success(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugSuccessLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
+    }
+    if (!this.loggingIsDebug()) {
+      return
     }
+    this.logWith('success', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugSuccessLog', String(...log))
   }
 
-  async warnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.warn(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  warnLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('warn', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugWarnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.warn(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugWarnLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    this.logWith('warn', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugWarnLog', String(...log))
   }
 
-  async errorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.error(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  errorLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('error', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugErrorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.error(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugErrorLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    this.logWith('error', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugErrorLog', String(...log))
   }
 
-  async debugLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (this.deviceLogging === 'debug') {
-        this.log.info(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      } else if (this.deviceLogging === 'debugMode') {
-        this.log.debug(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  debugLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
+    }
+    if (this.deviceLogging === 'debug') {
+      this.logWith('debug', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugLog', String(...log))
+    } else if (this.deviceLogging === 'debugMode') {
+      this.logWith('debug', `${this.device.remoteType}: ${this.accessory.displayName}`, 'debugLog', String(...log))
+    }
+  }
+
+  // Generic platform/local logger delegate
+  protected logWith(level: string, message: string, platformMethodName?: string, payload?: string): void {
+    const method = platformMethodName ?? `${level}Log`
+    const pFn = (this.platform as any)?.[method]
+    if (typeof pFn === 'function') {
+      try {
+        if (payload !== undefined) {
+          pFn(message, payload)
+        } else {
+          pFn(message)
+        }
+        return
+      } catch (_err) {
+        // fallthrough to local logger
+      }
+    }
+    const map: Record<string, string> = {
+      info: 'info',
+      success: 'success',
+      debug: 'debug',
+      warn: 'warn',
+      error: 'error',
+    }
+    const local = (this.log as any)[map[level] ?? level]
+    if (typeof local === 'function') {
+      if (payload !== undefined) {
+        local.call(this.log, message, payload)
+      } else {
+        local.call(this.log, message)
       }
     }
   }
 
-  async loggingIsDebug(): Promise<boolean> {
+  loggingIsDebug(): boolean {
     return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug'
   }
 
-  async enablingDeviceLogging(): Promise<boolean> {
+  enablingDeviceLogging(): boolean {
     return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug' || this.deviceLogging === 'standard'
   }
 }

package/src/platform-hap.ts

@@ -55,7 +55,7 @@ import { TV } from './irdevice/tv.js'
 import { VacuumCleaner } from './irdevice/vacuumcleaner.js'
 import { WaterHeater } from './irdevice/waterheater.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { cleanDeviceConfig, formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, safeStringify, sleep } from './utils.js'
+import { ApiRequestTracker, cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, safeStringify, sleep } from './utils.js'
 
 /**
  * HomebridgePlatform
@@ -68,6 +68,18 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
   public readonly api: API
   public readonly log: Logging
 
+  // Logging helper functions (attached from utils.createPlatformLogger in constructor)
+  infoLog!: (...log: any[]) => Promise<void>
+  successLog!: (...log: any[]) => Promise<void>
+  debugSuccessLog!: (...log: any[]) => Promise<void>
+  warnLog!: (...log: any[]) => Promise<void>
+  debugWarnLog!: (...log: any[]) => Promise<void>
+  errorLog!: (...log: any[]) => Promise<void>
+  debugErrorLog!: (...log: any[]) => Promise<void>
+  debugLog!: (...log: any[]) => Promise<void>
+  loggingIsDebug!: () => Promise<boolean>
+  enablingPlatformLogging!: () => Promise<boolean>
+
   // Configuration properties
   platformConfig!: SwitchBotPlatformConfig
   platformLogging!: options['logging']
@@ -88,6 +100,9 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
   switchBotAPI!: SwitchBotOpenAPI
   switchBotBLE!: SwitchBotBLE
 
+  // API request tracking
+  private apiTracker?: ApiRequestTracker
+
   // External APIs
   public readonly eve: any
   public readonly fakegatoAPI: any
@@ -104,9 +119,22 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     this.api = api
     this.log = log
 
+    // Attach shared platform logging helpers (moved to utils for reuse)
+    const _pl = createPlatformLogger(async () => this.platformLogging, this.log)
+    this.infoLog = _pl.infoLog
+    this.successLog = _pl.successLog
+    this.debugSuccessLog = _pl.debugSuccessLog
+    this.warnLog = _pl.warnLog
+    this.debugWarnLog = _pl.debugWarnLog
+    this.errorLog = _pl.errorLog
+    this.debugErrorLog = _pl.debugErrorLog
+    this.debugLog = _pl.debugLog
+    this.loggingIsDebug = _pl.loggingIsDebug
+    this.enablingPlatformLogging = _pl.enablingPlatformLogging
+
     // only load if configured
     if (!config) {
-      this.log.error('No configuration found for the plugin, please check your config.')
+      this.errorLog('No configuration found for the plugin, please check your config.')
       return
     }
 
@@ -119,6 +147,20 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       devices: config.devices as { deviceId: string }[],
     }
 
+    // Determine platform logging preference (match HAP behaviour as closely as
+    // possible using config values. We default to 'standard' when unspecified.)
+    this.platformLogging = (this.config.options?.logging === 'debug' || this.config.options?.logging === 'standard' || this.config.options?.logging === 'none')
+      ? this.config.options.logging
+      : 'standard'
+
+    // Unconditional diagnostic using the raw Homebridge `log` so it always
+    // appears regardless of the platform logging helpers' gating logic.
+    try {
+      this.log.debug?.(`[SwitchBot HAP] effective platformLogging=${String(this.platformLogging)}`)
+    } catch (e: any) {
+      // swallow any logging errors — diagnostics are best-effort
+    }
+
     // Normalize deviceConfig to remove UI-inserted defaults (lots of false/empty values)
     try {
       if ((this.config as any).options) {
@@ -203,9 +245,29 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     // to start discovery of new accessories.
     this.api.on('didFinishLaunching', async () => {
       this.debugLog('Executed didFinishLaunching callback')
+
+      // Initialize API request tracking
+      try {
+        this.apiTracker = new ApiRequestTracker(this.api, this.log, 'SwitchBot HAP')
+        this.apiTracker.startHourlyLogging()
+      } catch (e: any) {
+        this.errorLog(`Failed to initialize API request tracking: ${e.message ?? e}`)
+      }
+
       // run the method to discover / register your devices as accessories
       try {
-        await this.discoverDevices()
+        // Does the user have a version of Homebridge that is compatible with matter?
+        if (!this.api.isMatterAvailable?.()) {
+          this.debugLog(`Matter is not available in this version of Homebridge. Please update Homebridge to use this plugin, ${this.api.isMatterAvailable?.() ? '' : ' (Matter is not available in this version of Homebridge)'}`)
+        }
+        if (!this.api.isMatterEnabled?.()) {
+          this.debugLog(`Matter is not enabled in Homebridge. Please enable Matter in the Homebridge settings to use this plugin, ${this.api.isMatterEnabled?.() ? '' : ' (Matter is not enabled in Homebridge)'}`)
+        }
+        if (!this.api.isMatterAvailable?.() && !this.api.isMatterEnabled?.()) {
+          await this.discoverDevices()
+        } else {
+          this.infoLog('Matter is enabled in Homebridge. SwitchBot Matter devices will be handled by the Matter platform.')
+        }
       } catch (e: any) {
         this.errorLog(`Failed to Discover, Error Message: ${e.message ?? e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug')
         this.debugErrorLog(`Failed to Discover, Error: ${e.message ?? e}`)
@@ -440,6 +502,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
 
     while (retryCount < maxRetries) {
       try {
+        this.apiTracker?.track()
         const { response, statusCode } = await this.switchBotAPI.getDevices()
         this.debugLog(`response: ${JSON.stringify(response)}`)
         if (this.isSuccessfulResponse(statusCode)) {
@@ -2752,6 +2815,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     const delayBetweenRetries = deviceDelayBetweenRetries
     while (retryCount < maxRetries) {
       try {
+        this.apiTracker?.track()
         const { response, statusCode } = await this.switchBotAPI.getDeviceStatus(device.deviceId, this.config.credentials?.token, this.config.credentials?.secret)
         this.debugLog(`response: ${JSON.stringify(response)}`)
         return { response, statusCode }
@@ -2777,6 +2841,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     const delayBetweenRetries = deviceDelayBetweenRetries ?? 1000
     while (retryCount < maxRetries) {
       try {
+        this.apiTracker?.track()
         const { response, statusCode } = await this.switchBotAPI.controlDevice(
           device.deviceId,
           bodyChange.command,
@@ -2913,74 +2978,4 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       return value
     }
   }
-
-  /**
-   * If device level logging is turned on, log to log.warn
-   * Otherwise send debug logs to log.debug
-   */
-  async infoLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      this.log.info(String(...log))
-    }
-  }
-
-  async successLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      this.log.success(String(...log))
-    }
-  }
-
-  async debugSuccessLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.success('[DEBUG]', String(...log))
-      }
-    }
-  }
-
-  async warnLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      this.log.warn(String(...log))
-    }
-  }
-
-  async debugWarnLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.warn('[DEBUG]', String(...log))
-      }
-    }
-  }
-
-  async errorLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      this.log.error(String(...log))
-    }
-  }
-
-  async debugErrorLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.error('[DEBUG]', String(...log))
-      }
-    }
-  }
-
-  async debugLog(...log: any[]): Promise<void> {
-    if (await this.enablingPlatformLogging()) {
-      if (this.platformLogging === 'debug') {
-        this.log.info('[DEBUG]', String(...log))
-      } else if (this.platformLogging === 'debugMode') {
-        this.log.debug(String(...log))
-      }
-    }
-  }
-
-  async loggingIsDebug(): Promise<boolean> {
-    return this.platformLogging === 'debugMode' || this.platformLogging === 'debug'
-  }
-
-  async enablingPlatformLogging(): Promise<boolean> {
-    return this.platformLogging === 'debugMode' || this.platformLogging === 'debug' || this.platformLogging === 'standard'
-  }
 }