@scrypted/server 0.4.9 → 0.4.10

package/src/plugin/system.ts

@@ -166,15 +166,11 @@ export class SystemManagerImpl implements SystemManager {
         return this.events.listen(makeOneWayCallback((id, eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData)));
     }
     listenDevice(id: string, options: string | EventListenerOptions, callback: EventListener): EventListenerRegister {
-        let { event, watch } = (options || {}) as EventListenerOptions;
-        if (!event && typeof options === 'string')
-            event = options as string;
-        if (!event)
-            event = undefined;
+        let { watch } = (options || {}) as EventListenerOptions;
 
         // passive watching can be fast pathed to observe local state
         if (watch)
-            return this.events.listenDevice(id, event, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData));
+            return this.events.listenDevice(id, options, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData));
 
         return new EventListenerRegisterImpl(this.api.listenDevice(id, options, makeOneWayCallback((eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData))));
     }

package/src/rpc.ts

@@ -154,6 +154,9 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
 
         if (this.proxyOneWayMethods?.includes?.(method)) {
             rpcApply.oneway = true;
+            // a oneway callable object doesn't need to be in the JSON payload.
+            if (method === null)
+                delete rpcApply.method;
             this.peer.send(rpcApply, undefined, serializationContext);
             return Promise.resolve();
         }

package/src/services/plugin.ts

@@ -70,6 +70,8 @@ export class PluginComponent {
     async kill(pluginId: string) {
         return this.scrypted.plugins[pluginId]?.kill();
     }
+    // TODO: Remove this, ScryptedPlugin exists now.
+    // 12/29/2022
     async getPackageJson(pluginId: string) {
         return this.scrypted.getPackageJson(pluginId);
     }

package/src/state.ts

@@ -1,9 +1,9 @@
 import { EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
 import throttle from 'lodash/throttle';
 import { PluginDevice } from "./db-types";
-import { EventListenerRegisterImpl, EventRegistry } from "./event-registry";
-import { allInterfaceProperties, propertyInterfaces } from "./plugin/descriptor";
-import { RefreshSymbol } from "./plugin/plugin-device";
+import { EventListenerRegisterImpl, EventRegistry, getMixinEventName } from "./event-registry";
+import { propertyInterfaces } from "./plugin/descriptor";
+import { QueryInterfaceSymbol, RefreshSymbol } from "./plugin/plugin-device";
 import { ScryptedRuntime } from "./runtime";
 import { sleep } from "./sleep";
 
@@ -34,25 +34,74 @@ export class ScryptedStateManager extends EventRegistry {
         this.scrypted = scrypted;
     }
 
-    setPluginState(pluginId: string, nativeId: ScryptedNativeId, eventInterface: ScryptedInterface, property: string, value: any) {
-        const device = this.scrypted.findPluginDevice(pluginId, nativeId);
+    async getImplementerId(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string) {
+        if (!eventInterface)
+            throw new Error(`ScryptedInterface is required`);
+
+        const device = this.scrypted.getDevice(pluginDevice._id);
         if (!device)
-            throw new Error(`device not found for plugin id ${pluginId} native id ${nativeId}`);
-        this.setPluginDeviceState(device, property, value, eventInterface);
+            throw new Error(`device ${pluginDevice._id} not found?`);
+
+        const implementerId: string = await (device as any)[QueryInterfaceSymbol](eventInterface);
+        return implementerId;
+    }
+
+    async notifyInterfaceEventFromMixin(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId: string) {
+        // TODO: figure out how to clean this up this hack. For now,
+        // Settings interface is allowed to bubble from mixin devices..
+        if (eventInterface !== ScryptedInterface.Settings) {
+            const implementerId = await this.getImplementerId(pluginDevice, eventInterface);
+            if (implementerId !== mixinId) {
+                const event = getMixinEventName({
+                    event: eventInterface,
+                    mixinId,
+                });
+
+                this.notifyEventDetails(pluginDevice._id, {
+                    eventId: undefined,
+                    eventInterface,
+                    eventTime: Date.now(),
+                    mixinId,
+                }, value, event);
+
+                return;
+            }
+        }
+
+        this.notify(pluginDevice?._id, Date.now(), eventInterface, undefined, value);
+    }
+
+    async setPluginDeviceStateFromMixin(pluginDevice: PluginDevice, property: string, value: any, eventInterface: ScryptedInterface, mixinId: string) {
+        const implementerId = await this.getImplementerId(pluginDevice, eventInterface);
+        if (implementerId !== mixinId) {
+            const event = getMixinEventName({
+                event: eventInterface,
+                mixinId,
+            });
+            this.scrypted.getDeviceLogger(pluginDevice).log('i', `${property}: ${value} (mixin)`);
+            this.notifyEventDetails(pluginDevice._id, {
+                eventId: undefined,
+                eventInterface,
+                eventTime: Date.now(),
+                mixinId,
+                property,
+            }, value, event);
+            return false;
+        }
+
+        return this.setPluginDeviceState(pluginDevice, property, value, eventInterface);
     }
 
     setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: ScryptedInterface) {
         eventInterface = eventInterface || propertyInterfaces[property];
         if (!eventInterface)
-            throw new Error(`${property} is not a valid property`);
+            throw new Error(`eventInterface must be provided`);
 
         const changed = setState(device, property, value);
 
-        const eventTime = device?.state?.[property]?.lastEventTime;
-
         if (eventInterface !== ScryptedInterface.ScryptedDevice) {
-            if (this.notify(device?._id, eventTime, eventInterface, property, value, changed) && device) {
-                this.scrypted.getDeviceLogger(device).log('i', `state change: ${property} ${value}`);
+            if (this.notify(device?._id, Date.now(), eventInterface, property, value, { changed }) && device) {
+                this.scrypted.getDeviceLogger(device).log('i', `${property}: ${value}`);
             }
         }
 
@@ -63,15 +112,18 @@ export class ScryptedStateManager extends EventRegistry {
     }
 
     updateDescriptor(device: PluginDevice) {
-        this.notify(device._id, undefined, ScryptedInterface.ScryptedDevice, undefined, device.state, true);
+        this.notify(device._id, undefined, ScryptedInterface.ScryptedDevice, undefined, device.state, { changed: true });
     }
 
     removeDevice(id: string) {
-        this.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
+        this.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, { changed: true });
     }
 
-    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any) {
-        this.notify(device?._id, Date.now(), eventInterface, undefined, value, true);
+    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId?: string) {
+        this.notify(device?._id, Date.now(), eventInterface, undefined, value, {
+            changed: true,
+            mixinId,
+        });
     }
 
     setState(id: string, property: string, value: any) {
@@ -214,12 +266,8 @@ export function setState(pluginDevice: PluginDevice, property: string, value: an
     if (!pluginDevice.state[property])
         pluginDevice.state[property] = {};
     const state = pluginDevice.state[property];
-    const now = Date.now();
     const changed = !isSameValue(value, state.value);
-    if (changed)
-        state.stateTime = now;
     state.value = value;
-    state.lastEventTime = now;
     return changed;
 }