homey-api 1.5.13 → 1.5.16

package/lib/HomeyAPI/HomeyAPIV2/Device.js

@@ -113,32 +113,105 @@ class Device extends Item {
   async connect() {
     this.__debug('connect');
 
-    if (!this.io) {
-      this.io = await this.homey.subscribe(this.uri, {
-        onConnect: () => {
-          this.__debug('onConnect');
-          this.__connected = true;
-        },
-        onDisconnect: () => {
-          this.__debug('onDisconnect');
-          this.__connected = false;
-        },
-        onEvent: (event, data) => {
-          // // Fire event listeners
-          if (Array.isArray(this.__listeners[event])) {
-            this.__listeners[event].forEach(listener => listener(data));
-          }
-        },
+    // If disconnecting, await that first
+    try {
+      await this.__disconnectPromise;
+    } catch (err) { }
+
+    this.__connectPromise = Promise.resolve().then(async () => {
+      if (!this.io) {
+        this.io = this.homey.subscribe(this.uri, {
+          onConnect: () => {
+            this.__debug('onConnect');
+            this.__connected = true;
+          },
+          onDisconnect: () => {
+            this.__debug('onDisconnect');
+            this.__connected = false;
+          },
+          onReconnect: () => {
+            this.__debug('onDisconnect');
+
+            const capabilityInstances = this.__capabilityInstances;
+            if (Object.keys(capabilityInstances).length > 0) {
+              // Get the device's latest values
+              // TODO: Optimize this with `getDevices()` when >1 device has >0 capability instances.
+              this.manager.getDevice({
+                id: this.id,
+              }).then(async device => {
+                Object.entries(capabilityInstances).forEach(([capabilityId, capabilityInstance]) => {
+                  const value = device.capabilitiesObj
+                    ? typeof device.capabilitiesObj[capabilityId] !== 'undefined'
+                      ? device.capabilitiesObj[capabilityId].value
+                      : null
+                    : null;
+
+                  capabilityInstance.__onCapabilityValue({
+                    capabilityId,
+                    value,
+                    transactionId: Util.uuid(),
+                  });
+                });
+              })
+                // eslint-disable-next-line no-console
+                .catch(err => console.error(`Device[${this.id}].onReconnectError:`, err));
+            }
+          },
+          onEvent: (event, data) => {
+            // // Fire event listeners
+            if (Array.isArray(this.__listeners[event])) {
+              this.__listeners[event].forEach(listener => listener(data));
+            }
+          },
+        });
+      }
+
+      await this.io;
+    });
+
+    // Delete the connecting Promise
+    this.__connectPromise
+      .catch(() => { })
+      .finally(() => {
+        delete this.__connectPromise;
       });
-    }
+
+    await this.__connectPromise;
   }
 
   async disconnect() {
     this.__debug('disconnect');
 
-    if (this.io) {
-      this.io.unsubscribe();
-    }
+    // If connecting, await that first
+    try {
+      await this.__connectPromise;
+    } catch (err) { }
+
+    this.__disconnectPromise = Promise.resolve().then(async () => {
+      this.__connected = false;
+
+      if (this.io) {
+        this.io
+          .then(io => io.unsubscribe())
+          .catch(err => this.__debug('Error Disconnecting:', err));
+      }
+    });
+
+    // Delete the disconnecting Promise
+    this.__disconnectPromise
+      .catch(() => { })
+      .finally(() => {
+        delete this.__disconnectPromise;
+      });
+
+    await this.__disconnectPromise;
+  }
+
+  destroy() {
+    super.destroy();
+
+    // Disconnect from Socket.io
+    this.disconnect().catch(() => { });
   }
 
 }

package/lib/HomeyAPI/HomeyAPIV2/DeviceCapability.js

@@ -74,6 +74,7 @@ class DeviceCapability extends EventEmitter {
     this.emit('destroy');
     this.device.off('capability', this.__onCapabilityValue);
     this.device.off('delete', this.__onDeviceDelete);
+    this.removeAllListeners();
   }
 
   __onCapabilityValue({

package/lib/HomeyAPI/HomeyAPIV2/Item.js

@@ -55,7 +55,8 @@ class Item extends EventEmitter {
   }
 
   destroy() {
-    // TODO
+    // Remove all event listeners
+    this.removeAllListeners();
   }
 
 }

package/lib/HomeyAPI/HomeyAPIV2/Manager.js

@@ -253,6 +253,7 @@ class Manager extends EventEmitter {
             } else {
               // Get from HTTP
               result = await this.homey.call({
+                $timeout,
                 headers,
                 body,
                 path: `/api/manager/${this.id}${path}`,
@@ -383,80 +384,102 @@ class Manager extends EventEmitter {
   async connect() {
     this.__debug('connect');
 
-    if (!this.io) {
-      this.io = await this.homey.subscribe(this.uri, {
-        onConnect: () => {
-          this.__debug('onConnect');
-          this.__connected = true;
-        },
-        onDisconnect: () => {
-          this.__debug('onDisconnect');
-          this.__connected = false;
-
-          // Clear CRUD Item cache
-          for (const itemId of Object.keys(this.__cache)) {
-            this.__cache[itemId] = {};
-            this.__cacheAllComplete[itemId] = false;
-          }
-        },
-        onEvent: (event, data) => {
-          this.__debug('onEvent', event);
-
-          // Transform & add to cache if this is a CRUD event
-          if (event.endsWith('.create')
-            || event.endsWith('.update')
-            || event.endsWith('.delete')) {
-            const [itemId, operation] = event.split('.');
-            const ItemClass = this.constructor.ITEMS[itemId] || Item;
-            const itemType = this.__itemsById[itemId].type;
-            const key = itemType === 'filter'
-              ? `${data.uri}:${data.id}`
-              : `${data.id}`;
-
-            switch (operation) {
-              case 'create': {
-                this.__cache[itemId][key] = new ItemClass({
-                  key,
-                  manager: this,
-                  properties: { ...data },
-                });
-                this.__cache[itemId][key].emit('create', data);
+    // If disconnecting, await that first
+    try {
+      await this.__disconnectPromise;
+    } catch (err) { }
+
+    this.__connectPromise = Promise.resolve().then(async () => {
+      if (!this.io) {
+        this.io = this.homey.subscribe(this.uri, {
+          onConnect: () => {
+            this.__debug('onConnect');
+            this.__connected = true;
+          },
+          onDisconnect: () => {
+            this.__debug('onDisconnect');
+            this.__connected = false;
+
+            // Clear CRUD Item cache
+            for (const itemId of Object.keys(this.__cache)) {
+              this.__cache[itemId] = {};
+              this.__cacheAllComplete[itemId] = false;
+            }
+          },
+          onEvent: (event, data) => {
+            this.__debug('onEvent', event);
+
+            // Transform & add to cache if this is a CRUD event
+            if (event.endsWith('.create')
+              || event.endsWith('.update')
+              || event.endsWith('.delete')) {
+              const [itemId, operation] = event.split('.');
+              const ItemClass = this.constructor.ITEMS[itemId] || Item;
+              const itemType = this.__itemsById[itemId].type;
+              const key = itemType === 'filter'
+                ? `${data.uri}:${data.id}`
+                : `${data.id}`;
+
+              switch (operation) {
+                case 'create': {
+                  this.__cache[itemId][key] = new ItemClass({
+                    key,
+                    manager: this,
+                    properties: { ...data },
+                  });
+                  this.__cache[itemId][key].emit('create', data);
 
-                data = this.__cache[itemId][key];
+                  data = this.__cache[itemId][key];
 
-                break;
-              }
-              case 'update': {
-                if (this.__cache[itemId][key]) {
-                  this.__cache[itemId][key].__update(data);
-                  this.__cache[itemId][key].emit('update', data);
+                  break;
                 }
+                case 'update': {
+                  if (this.__cache[itemId][key]) {
+                    this.__cache[itemId][key].__update(data);
+                    this.__cache[itemId][key].emit('update', data);
+                  } else {
+                    this.__cache[itemId][key] = new ItemClass({
+                      key,
+                      manager: this,
+                      properties: { ...data },
+                    });
+                  }
 
-                data = this.__cache[itemId][key];
+                  data = this.__cache[itemId][key];
 
-                break;
-              }
-              case 'delete': {
-                if (this.__cache[itemId][key]) {
-                  this.__cache[itemId][key].emit('delete');
-                  this.__cache[itemId][key].destroy();
-                  delete this.__cache[itemId][key];
-                  data = null;
+                  break;
                 }
-                break;
+                case 'delete': {
+                  if (this.__cache[itemId][key]) {
+                    this.__cache[itemId][key].emit('delete');
+                    this.__cache[itemId][key].destroy();
+                    delete this.__cache[itemId][key];
+                    data = null;
+                  }
+                  break;
+                }
+                default:
+                  break;
               }
-              default:
-                break;
             }
-          }
 
-          // Fire event listeners
-          if (Array.isArray(this.__listeners[event])) {
-            this.__listeners[event].forEach(listener => listener(data));
-          }
-        },
+            // Fire event listeners
+            this.emit(event, data);
+          },
+        });
+      }
+
+      await this.io;
+    });
+
+    // Delete the connecting Promise
+    this.__connectPromise
+      .catch(() => { })
+      .finally(() => {
+        delete this.__connectPromise;
       });
-    }
+
+    await this.__connectPromise;
   }
 
   /**
@@ -466,12 +489,35 @@ class Manager extends EventEmitter {
   async disconnect() {
     this.__debug('disconnect');
 
-    if (this.io) {
-      this.io.unsubscribe();
-    }
+    // If connecting, await that first
+    try {
+      await this.__connectPromise;
+    } catch (err) { }
+
+    this.__disconnectPromise = Promise.resolve().then(async () => {
+      this.__connected = false;
+
+      if (this.io) {
+        await this.io
+          .then(io => io.unsubscribe())
+          .catch(err => this.__debug('Error Disconnecting:', err));
+
+        delete this.io;
+      }
+    });
+
+    // Delete the disconnecting Promise
+    this.__disconnectPromise
+      .catch(() => { })
+      .finally(() => {
+        delete this.__disconnectPromise;
+      });
+
+    await this.__disconnectPromise;
   }
 
   destroy() {
+    // Clear cache
     for (const id of Object.keys(this.__cache)) {
       this.__cache[id] = {};
     }
@@ -480,6 +526,10 @@ class Manager extends EventEmitter {
       this.__cacheAllComplete[id] = false;
     }
 
+    // Remove all event listeners
+    this.removeAllListeners();
+
+    // Disconnect from Socket.io
     this.disconnect().catch(() => { });
   }
 

package/lib/HomeyAPI/HomeyAPIV2.js

@@ -184,9 +184,12 @@ class HomeyAPIV2 extends HomeyAPI {
 
     // Don't discover, just set the only strategy
     if (Object.keys(urls).length === 1) {
+      this.__baseUrl = Object.values(urls)[0];
+      this.__strategyId = Object.keys(urls)[0];
+
       return {
-        strategyId: Object.keys(urls)[0],
-        baseUrl: Object.values(urls)[0],
+        baseUrl: this.__baseUrl,
+        strategyId: this.__strategyId,
       };
     }
 
@@ -285,8 +288,6 @@ class HomeyAPIV2 extends HomeyAPI {
             promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.MDNS]);
           }
 
-          // TODO: Move this to the catch handler to always fallback on cloud
-          // Now mdns or local will error first and cloud won't have a chance!!
           if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
             promises.push(pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]);
           }
@@ -298,7 +299,16 @@ class HomeyAPIV2 extends HomeyAPI {
           return Promise.race(promises);
         })
         .then(result => resolve(result))
-        .catch(() => reject(new HomeyOfflineError()));
+        .catch(err => {
+          // Last resort: try cloud
+          if (pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD]) {
+            return pings[HomeyAPI.DISCOVERY_STRATEGIES.CLOUD].catch(err => {
+              throw new HomeyOfflineError(err);
+            });
+          }
+
+          reject(new HomeyOfflineError(err));
+        });
     } else if (pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]) {
       pings[HomeyAPI.DISCOVERY_STRATEGIES.LOCAL]
         .then(result => resolve(result))
@@ -526,6 +536,7 @@ class HomeyAPIV2 extends HomeyAPI {
 
     return {
       unsubscribe: () => {
+        this.__ioNamespace.emit('unsubscribe', uri);
         this.__ioNamespace.removeListener(uri, __onEvent);
         this.__io.removeListener('disconnect', __onDisconnect);
         this.__io.removeListener('reconnect', __onReconnect);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "1.5.13",
+  "version": "1.5.16",
   "description": "Homey API",
   "main": "src/index.js",
   "types": "assets/types/homey-api.d.ts",