@switchbot/homebridge-switchbot 5.1.0-beta.9 → 5.1.1

package/src/deviceFactory.ts

@@ -64,6 +64,9 @@ const DEVICE_CLASS_MAP: Record<string, any> = {
   'meterplus': MeterDevice,
   'meterpro': MeterDevice,
   'meterpro(co2)': MeterDevice,
+  'meter plus': MeterDevice,
+  'meter pro': MeterDevice,
+  'meter pro (co2)': MeterDevice,
   'walletfinder': WalletFinderDevice,
   'plug': PlugDevice,
   'plug mini (eu)': PlugMiniDevice,
@@ -109,6 +112,7 @@ const DEVICE_CLASS_MAP: Record<string, any> = {
   'meter': MeterDevice,
   'meter plus (jp)': MeterDevice,
   'water detector': WaterDetectorDevice,
+  'waterdetector': WaterDetectorDevice,
   'smart fan': SmartFanDevice,
   'strip light': StripLightDevice,
   'wosweeper': WoSweeperDevice,
@@ -137,7 +141,8 @@ const DEVICE_CLASS_MAP: Record<string, any> = {
 
 function classForType(type: string) {
   const rawKey = (type || '').toLowerCase()
-  const key = DEVICE_TYPE_NORMALIZATION_MAP[rawKey] ?? rawKey
+  // Normalised types are canonical display names; class map keys are lowercase
+  const key = (DEVICE_TYPE_NORMALIZATION_MAP[rawKey] ?? rawKey).toLowerCase()
   return DEVICE_CLASS_MAP[key] ?? GenericDevice
 }
 
@@ -176,20 +181,10 @@ export async function createDevice(opts: DeviceOptions, cfg: SwitchBotPluginConf
   const device = new DeviceCtor(deviceOpts, mergedCfg)
   await device.init()
 
-  // Attach a simple getState delegator to the client where appropriate
-  const originalGetState = device.getState.bind(device)
-  device.getState = async () => {
-    try {
-      // Prefer client-backed getDevice when available
-      const dev = await client.getDevice(opts.id)
-      if (dev) {
-        return dev
-      }
-    } catch (e) {
-      // ignore and fallback to device implementation
-    }
-    return originalGetState()
-  }
+  // No getState() override here: the device's own implementation already
+  // prefers the client-backed lookup, and it converts the result into a status.
+  // An override that returned the client device directly shadowed it, and that
+  // object carries no readings.
 
   // Provide accessory factory based on platform selection
   return {

package/src/devices/genericDevice.ts

@@ -186,7 +186,44 @@ export class GenericDevice extends DeviceBase {
     })
   }
 
+  /**
+   * How long a fetched state is reused. HomeKit reads every characteristic of
+   * an accessory together, so without this a single read costs one API request
+   * per characteristic.
+   */
+  private static readonly STATE_TTL_MS = 15_000
+
+  /** Marks a state that carries no readings, so a caller can skip it. */
+  static readonly UNREADABLE = Symbol('unreadable')
+
+  private stateCache?: { at: number, value: any }
+  private stateInFlight?: Promise<any>
+
   async getState(): Promise<any> {
+    if (this.stateCache && (Date.now() - this.stateCache.at) < GenericDevice.STATE_TTL_MS) {
+      return this.stateCache.value
+    }
+    // Collapse the burst of reads HomeKit makes into a single fetch.
+    if (this.stateInFlight) {
+      return this.stateInFlight
+    }
+    this.stateInFlight = this.fetchState()
+      .then((value) => {
+        if (value === GenericDevice.UNREADABLE) {
+          // Do not cache a failure. Caching it would hold every characteristic
+          // at its fallback for the whole window after one transient error.
+          return { id: this.opts.id, type: this.opts.type, unreadable: true }
+        }
+        this.stateCache = { at: Date.now(), value }
+        return value
+      })
+      .finally(() => {
+        this.stateInFlight = undefined
+      })
+    return this.stateInFlight
+  }
+
+  protected async fetchState(): Promise<any> {
     // Default: return minimal info; implementations should override
     if (this.client && typeof this.client.getDevice === 'function') {
       try {
@@ -201,15 +238,27 @@ export class GenericDevice extends DeviceBase {
         // Normalize common response shapes
         try {
           const device = raw?.body ?? raw
-          return device
-        } catch (e) {
-          return raw
+          // node-switchbot returns a device instance, not a status. The instance
+          // exposes id/name/deviceType/mac but carries no readings, so a caller
+          // reading state.temperature would get undefined. Ask it for status.
+          if (device && typeof device.getStatus === 'function') {
+            const status = await device.getStatus()
+            if (status && typeof status === 'object') {
+              return status
+            }
+            // Fall through to the minimal info below rather than returning the
+            // instance, which would look like a state with every field missing.
+          } else {
+            return device
+          }
+        } catch (e: any) {
+          this.log?.debug?.(`getState: could not read status for ${this.opts.id}:`, e instanceof Error ? e.message : e)
         }
       } catch (e) {
         // ignore and fallback
       }
     }
-    return { id: this.opts.id, type: this.opts.type }
+    return GenericDevice.UNREADABLE
   }
 
   async setState(change: any): Promise<any> {
@@ -483,6 +532,38 @@ export class GenericDevice extends DeviceBase {
 export class BotDevice extends GenericDevice {}
 
 export class CurtainDevice extends GenericDevice {
+  private lastKnownPosition = 0
+  private lastTargetPosition = 0
+  private positionState = 2
+  private preferLocalPositionUntil = 0
+
+  private clampHomeKitPosition(position: number): number {
+    return Math.max(0, Math.min(100, Math.round(Number(position))))
+  }
+
+  private toHomeKitPosition(switchBotPosition: number): number {
+    return 100 - this.clampHomeKitPosition(switchBotPosition)
+  }
+
+  private toSwitchBotPosition(homeKitPosition: number): number {
+    return 100 - this.clampHomeKitPosition(homeKitPosition)
+  }
+
+  private async getPositionForHomeKit(): Promise<number> {
+    if (Date.now() < this.preferLocalPositionUntil) {
+      return this.lastKnownPosition
+    }
+    const state = await Promise.race([
+      this.getState(),
+      new Promise(resolve => setTimeout(resolve, 1000)),
+    ])
+    if (typeof state?.position === 'number') {
+      this.lastKnownPosition = this.toHomeKitPosition(Number(state.position))
+      this.lastTargetPosition = this.lastKnownPosition
+    }
+    return this.lastKnownPosition
+  }
+
   createHAPAccessory(api: any) {
     return {
       services: [
@@ -491,18 +572,27 @@ export class CurtainDevice extends GenericDevice {
           characteristics: {
             CurrentPosition: {
               get: async () => {
-                const s = await this.getState()
-                return typeof s.position === 'number' ? s.position : 0
+                return this.getPositionForHomeKit()
               },
             },
+            PositionState: {
+              get: async () => this.positionState,
+            },
             TargetPosition: {
               get: async () => {
-                const s = await this.getState()
-                return typeof s.position === 'number' ? s.position : 0
+                await this.getPositionForHomeKit()
+                return this.lastTargetPosition
               },
               set: async (v: any) => {
-                await this.setState({ position: Number(v) })
+                const position = this.clampHomeKitPosition(Number(v))
+                this.lastTargetPosition = position
+                this.positionState = position > this.lastKnownPosition ? 1 : position < this.lastKnownPosition ? 0 : 2
+                await this.setState({ position: this.toSwitchBotPosition(position) })
+                this.lastKnownPosition = position
+                this.preferLocalPositionUntil = Date.now() + 30000
+                this.positionState = 2
               },
+              refreshAfterSet: ['CurrentPosition', 'TargetPosition', 'PositionState'],
             },
           },
         },
@@ -1306,6 +1396,161 @@ export class MeterDevice extends GenericDevice {
 }
 
 export class WaterDetectorDevice extends GenericDevice {
+  private _leakRefreshing = false
+  private _leakRefreshTs = 0
+  private lastLeakDetected?: boolean
+  private readonly LEAK_REFRESH_TTL_MS = 30_000
+
+  private lastBatteryLevel?: number
+  private _batteryRefreshing = false
+  private _batteryRefreshTs = 0
+  private readonly BATTERY_REFRESH_TTL_MS = 30_000
+
+  async init(): Promise<void> {
+    await super.init()
+    await this._refreshLeakState(!this.client)
+    await this._refreshBattery()
+  }
+
+  private normalizeLeakDetected(state: any): boolean | undefined {
+    if (typeof state?.leak === 'boolean') {
+      return state.leak
+    }
+    if (typeof state?.waterLeakDetected === 'boolean') {
+      return state.waterLeakDetected
+    }
+    if (typeof state?.body?.waterLeakDetected === 'boolean') {
+      return state.body.waterLeakDetected
+    }
+    const status = state?.status ?? state?.body?.status
+    if (typeof status === 'number') {
+      return status === 1
+    }
+    if (typeof status === 'string') {
+      return ['1', 'leak', 'leaked', 'detected', 'water_leak_detected'].includes(status.toLowerCase())
+    }
+    return undefined
+  }
+
+  private normalizeBatteryLevel(state: any): number | undefined {
+    const raw = state?.battery ?? state?.body?.battery
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+      return undefined
+    }
+    return Math.max(0, Math.min(100, raw))
+  }
+
+  private async getOpenAPIStatus(): Promise<any> {
+    const token = this.cfg?.openApiToken
+    const secret = this.cfg?.openApiSecret
+    if (!token || !secret) {
+      return undefined
+    }
+
+    try {
+      const { OpenAPIClient } = await import('node-switchbot')
+      const apiClient = new OpenAPIClient(token, secret)
+      return await apiClient.getStatus(this.opts.id)
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] direct OpenAPI refresh failed: ${(e as Error)?.message}`)
+    }
+
+    return undefined
+  }
+
+  private async readLeakDetected(fallbackToDeviceState = true): Promise<boolean | undefined> {
+    const status = await this.getOpenAPIStatus()
+    if (status) {
+      const leak = this.normalizeLeakDetected(status)
+      if (typeof leak === 'boolean') {
+        return leak
+      }
+    }
+    if (!fallbackToDeviceState) {
+      return undefined
+    }
+
+    try {
+      return this.normalizeLeakDetected(await this.getState())
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] leak refresh failed: ${(e as Error)?.message}`)
+    }
+
+    return undefined
+  }
+
+  private async readBatteryLevel(): Promise<number | undefined> {
+    const status = await this.getOpenAPIStatus()
+    if (status) {
+      const battery = this.normalizeBatteryLevel(status)
+      if (typeof battery === 'number') {
+        return battery
+      }
+    }
+
+    return undefined
+  }
+
+  private async _refreshLeakState(fallbackToDeviceState = true): Promise<void> {
+    if (this._leakRefreshing) {
+      return
+    }
+    this._leakRefreshing = true
+    try {
+      const leakDetected = await this.readLeakDetected(fallbackToDeviceState)
+      if (typeof leakDetected === 'boolean') {
+        this.lastLeakDetected = leakDetected
+        this._leakRefreshTs = Date.now()
+      }
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] leak refresh failed: ${(e as Error)?.message}`)
+    } finally {
+      this._leakRefreshing = false
+    }
+  }
+
+  private async _refreshBattery(): Promise<void> {
+    if (this._batteryRefreshing) {
+      return
+    }
+    this._batteryRefreshing = true
+    try {
+      const battery = await this.readBatteryLevel()
+      if (typeof battery === 'number') {
+        this.lastBatteryLevel = battery
+        this._batteryRefreshTs = Date.now()
+      }
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] battery refresh failed: ${(e as Error)?.message}`)
+    } finally {
+      this._batteryRefreshing = false
+    }
+  }
+
+  private getLeakDetectedFast(api: any): number {
+    if (Date.now() - this._leakRefreshTs >= this.LEAK_REFRESH_TTL_MS) {
+      this._refreshLeakState().catch(() => undefined)
+    }
+    if (typeof this.lastLeakDetected === 'boolean') {
+      return this.lastLeakDetected ? 1 : 0
+    }
+    throw new api.hap.HapStatusError(api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE)
+  }
+
+  // Returns the cached battery level immediately and triggers a background
+  // refresh if the cache is stale. Throws HapStatusError on true cold start
+  // so HomeKit shows "Not Available" rather than fabricating a misleading
+  // value or timing out (which surfaces as 0% in the Home app).
+  private getBatteryFast(api: any): number {
+    if (Date.now() - this._batteryRefreshTs >= this.BATTERY_REFRESH_TTL_MS) {
+      this._refreshBattery().catch(() => undefined)
+    }
+    if (typeof this.lastBatteryLevel === 'number') {
+      return this.lastBatteryLevel
+    }
+    throw new api.hap.HapStatusError(api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE)
+  }
+
   createHAPAccessory(api: any) {
     return {
       services: [
@@ -1313,11 +1558,25 @@ export class WaterDetectorDevice extends GenericDevice {
           type: 'LeakSensor',
           characteristics: {
             LeakDetected: {
-              get: async () => {
-                const s = await this.getState()
-                return s && s.leak ? 1 : 0
+              get: () => this.getLeakDetectedFast(api),
+            },
+          },
+        },
+        {
+          type: 'Battery',
+          characteristics: {
+            BatteryLevel: {
+              get: () => this.getBatteryFast(api),
+            },
+            StatusLowBattery: {
+              get: () => {
+                const b = this.getBatteryFast(api)
+                return b < 20 ? 1 : 0
               },
             },
+            ChargingState: {
+              get: () => 2,
+            },
           },
         },
       ],

package/src/homebridge-ui/endpoints/config.ts

@@ -4,7 +4,7 @@ import { RequestError } from '@homebridge/plugin-ui-utils'
 import fs from 'node:fs/promises'
 
 import { isValidDeviceType } from '../../device-types.js'
-import { getAllDevices, isV4Config, SWITCHBOT_PLATFORM_REGEX } from '../utils/config-parser.js'
+import { getAllDevices, SWITCHBOT_PLATFORM_REGEX } from '../utils/config-parser.js'
 import { validateAndMigrateDeviceType } from '../utils/device-migration.js'
 import { uiLog } from '../utils/logger.js'
 
@@ -31,7 +31,6 @@ export function registerConfigEndpoints(server: HomebridgePluginUiServer) {
         typeValidationWarning?: string
       }> = []
       const invalidTypeDevices: Array<{ name: string, type: string, suggestion?: string }> = []
-      let v4ConfigDetected = false
 
       const platforms = Array.isArray(cfg.platforms) ? cfg.platforms : []
       for (const p of platforms) {
@@ -42,12 +41,6 @@ export function registerConfigEndpoints(server: HomebridgePluginUiServer) {
             continue
           }
 
-          // Detect legacy v4 config format
-          if (isV4Config(p)) {
-            v4ConfigDetected = true
-            uiLog.warn('Detected legacy v4 config format (credentials/options.devices). This config is not compatible with v5+. Please migrate to the v5 config format.')
-          }
-
           const devices = getAllDevices(p)
           for (const d of devices) {
             const id = d.deviceId ?? d.id
@@ -101,12 +94,11 @@ export function registerConfigEndpoints(server: HomebridgePluginUiServer) {
         )
       }
 
-      uiLog.info(`GET /devices - Found ${found.length} devices in ${cfgPath}${invalidTypeDevices.length > 0 ? ` (${invalidTypeDevices.length} with validation warnings)` : ''}${v4ConfigDetected ? ' [v4 config detected]' : ''}`)
+      uiLog.info(`GET /devices - Found ${found.length} devices in ${cfgPath}${invalidTypeDevices.length > 0 ? ` (${invalidTypeDevices.length} with validation warnings)` : ''}`)
       return {
         success: true,
         data: found,
         ...(invalidTypeDevices.length > 0 && { validationWarnings: invalidTypeDevices }),
-        ...(v4ConfigDetected && { v4ConfigDetected: true }),
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e)

package/src/homebridge-ui/public/css/styles.css

@@ -480,64 +480,4 @@ ul.device-grid {
 
 .discovery-scanning-pulse {
   animation: pulse 1.5s ease-in-out infinite;
-}
-/* v4 config incompatibility warning banner */
-.v4-config-warning {
-  background: #7c3015;
-  color: #fff;
-  border: 1px solid #a04020;
-  border-radius: 8px;
-  padding: 14px 18px;
-  margin-bottom: 18px;
-  font-size: 13px;
-  line-height: 1.5;
-}
-
-.v4-config-warning strong {
-  display: block;
-  font-size: 15px;
-  margin-bottom: 8px;
-}
-
-.v4-config-warning p {
-  margin: 6px 0;
-}
-
-.v4-config-warning ul {
-  margin: 6px 0 6px 18px;
-  padding: 0;
-}
-
-.v4-config-warning li {
-  margin-bottom: 3px;
-}
-
-.v4-config-warning code {
-  background: rgba(255, 255, 255, 0.15);
-  border-radius: 3px;
-  padding: 1px 4px;
-  font-size: 12px;
-  color: #ffd;
-}
-
-.v4-config-warning a {
-  color: #ffd;
-  text-decoration: underline;
-}
-
-@media (prefers-color-scheme: light) {
-  .v4-config-warning {
-    background: #fff3cd;
-    color: #7c3015;
-    border-color: #f0ad4e;
-  }
-
-  .v4-config-warning code {
-    background: rgba(124, 48, 21, 0.1);
-    color: #7c3015;
-  }
-
-  .v4-config-warning a {
-    color: #7c3015;
-  }
-}
+}

package/src/homebridge-ui/public/index.html

@@ -9,57 +9,8 @@
 </head>
 
 <body>
-
   <h1>🤖 SwitchBot Configuration</h1>
 
-  <!-- ...existing code... -->
-
-  <!-- Centered legacy view button at the bottom -->
-  <div class="centered-toggle-btn">
-    <button id="legacyViewBtn">Legacy View</button>
-    <button id="dynamicViewBtn" style="display: none;">Dynamic View</button>
-  </div>
-  <style>
-    .centered-toggle-btn {
-      display: flex;
-      flex-direction: row;
-      justify-content: center;
-      align-items: center;
-      margin-top: 32px;
-      margin-bottom: 12px;
-      gap: 12px;
-    }
-    #legacyViewBtn, #dynamicViewBtn {
-      font-size: 12px;
-      padding: 4px 10px;
-    }
-  </style>
-
-  <div id="dynamicUiContainer">
-
-  <!-- v4 config incompatibility warning – shown dynamically by app.js -->
-  <div id="v4ConfigWarning" class="v4-config-warning" style="display: none">
-    <strong>⚠️ Incompatible v4 Configuration Detected</strong>
-    <p>
-      Your config.json appears to be in the <strong>v4 format</strong> (using <code>credentials</code> and
-      <code>options.devices</code> fields). This format is <strong>not compatible with v5 or newer</strong> of the
-      SwitchBot plugin. Devices will not be recognised until the config is updated.
-    </p>
-    <p>
-      Please update your config to the v5 format:
-    </p>
-    <ul>
-      <li>Move <code>credentials.token</code> → <code>openApiToken</code> (top level)</li>
-      <li>Move <code>credentials.secret</code> → <code>openApiSecret</code> (top level)</li>
-      <li>Move <code>options.devices</code> → <code>devices</code> (top level)</li>
-      <li>Rename per-device <code>connectionType</code> → <code>connectionPreference</code></li>
-      <li>Remove the <code>credentials</code> and <code>options</code> wrapper objects</li>
-    </ul>
-    <p>
-      See the <a href="https://github.com/OpenWonderLabs/homebridge-switchbot/blob/latest/MIGRATION.md" target="_blank" rel="noopener">Migration Guide</a> for full details.
-    </p>
-  </div>
-
   <div class="card compact">
     <h2>API Credentials</h2>
     <div class="credentials-row">
@@ -253,18 +204,8 @@
     </form>
   </div>
 
-  </div> <!-- end dynamicUiContainer -->
-
-  <div id="legacyViewContainer" style="display: none;">
-    <div class="card compact">
-      <h2>Legacy Config View</h2>
-      <div id="legacyConfigForm"></div>
-    </div>
-  </div>
-
   <script type="module" src="js/app.js"></script>
   <script type="module" src="js/advanced-settings.js"></script>
-  <script type="module" src="js/legacy-view.js"></script>
 </body>
 
 </html>

package/src/homebridge-ui/public/js/advanced-settings.ts

@@ -46,11 +46,10 @@ async function saveAdvancedSettings(): Promise<void> {
     if (!Array.isArray(pluginConfigBlocks) || !pluginConfigBlocks.length) {
       throw new Error('No plugin config blocks returned from Homebridge')
     }
-    // Find or add the SwitchBot config block
-    let idx = pluginConfigBlocks.findIndex(c => (c.platform || c.name || '').toLowerCase().includes('switchbot'))
+    // Find the SwitchBot config block
+    const idx = pluginConfigBlocks.findIndex(c => (c.platform || c.name || '').toLowerCase().includes('switchbot'))
     if (idx === -1) {
-      pluginConfigBlocks.push({ platform: 'SwitchBot' })
-      idx = pluginConfigBlocks.length - 1
+      throw new Error('SwitchBot config not found')
     }
     const config = pluginConfigBlocks[idx]
     // Update config values from UI

package/src/homebridge-ui/public/js/api.ts

@@ -1,6 +1,5 @@
 // Fetch the list of configured devices from the Homebridge UI API
 import { isValidDeviceType, normalizeDeviceType } from '../../../device-types.js'
-import { isV4Config } from '../../utils/v4-detection.js'
 import './types.js'
 import { uiLog } from './logger.js'
 import { toastError } from './toast.js'
@@ -23,35 +22,6 @@ export async function fetchDevices(): Promise<any[]> {
   }
 }
 
-/**
- * Detect whether the current plugin config is in the legacy v4 format.
- *
- * v4 configs stored credentials under a `credentials` sub-object and devices
- * under `options.devices`. v5+ flattened these to `openApiToken`,
- * `openApiSecret`, and a root-level `devices` array.
- *
- * Returns true when a v4 config block is found, false otherwise.
- */
-export async function detectV4Config(): Promise<boolean> {
-  try {
-    if (typeof homebridge.getPluginConfig !== 'function') {
-      return false
-    }
-    const configArr = await homebridge.getPluginConfig()
-    if (!Array.isArray(configArr)) {
-      return false
-    }
-    const config = configArr.find(isSwitchBotPlatformConfig)
-    if (!config || typeof config !== 'object') {
-      return false
-    }
-    return isV4Config(config)
-  } catch (e) {
-    uiLog.warn('Error detecting v4 config:', e)
-    return false
-  }
-}
-
 /**
  * Validate and auto-correct device types in the config array before saving.
  * Returns an array of errors for devices that cannot be fixed.
@@ -219,19 +189,7 @@ export async function addDevice(
   deviceId: string,
   name: string,
   type: string,
-  options?: {
-    address?: string
-    model?: string
-    rssi?: number
-    connectionPreference?: string
-    externalPublishProtocol?: string
-    room?: string
-    encryptionKey?: string
-    keyId?: string
-    refreshRate?: number
-    blePollingEnabled?: boolean
-    blePollIntervalMs?: number
-  },
+  options?: { address?: string, model?: string, rssi?: number, encryptionKey?: string, keyId?: string },
 ): Promise<any> {
   if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
     throw new TypeError('Homebridge UI API not available')
@@ -266,24 +224,6 @@ export async function addDevice(
   if (options?.keyId) {
     newDevice.keyId = options.keyId
   }
-  if (options?.connectionPreference) {
-    newDevice.connectionPreference = options.connectionPreference
-  }
-  if (options?.externalPublishProtocol) {
-    newDevice.externalPublishProtocol = options.externalPublishProtocol
-  }
-  if (options?.room) {
-    newDevice.room = options.room
-  }
-  if (typeof options?.refreshRate === 'number' && Number.isFinite(options.refreshRate)) {
-    newDevice.refreshRate = options.refreshRate
-  }
-  if (typeof options?.blePollingEnabled === 'boolean') {
-    newDevice.blePollingEnabled = options.blePollingEnabled
-  }
-  if (typeof options?.blePollIntervalMs === 'number' && Number.isFinite(options.blePollIntervalMs)) {
-    newDevice.blePollIntervalMs = options.blePollIntervalMs
-  }
   config.devices.push(newDevice)
   await homebridge.updatePluginConfig(configArr)
   if (typeof homebridge.savePluginConfig === 'function') {