@scrypted/server 0.4.8 → 0.4.10

package/src/event-registry.ts

@@ -1,4 +1,4 @@
-import { EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterface, SystemDeviceState } from "@scrypted/types";
+import { EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterface } from "@scrypted/types";
 
 export class EventListenerRegisterImpl implements EventListenerRegister {
     removeListener: () => void;
@@ -8,6 +8,18 @@ export class EventListenerRegisterImpl implements EventListenerRegister {
     }
 }
 
+export function getMixinEventName(options: string | EventListenerOptions) {
+    let { event, mixinId } = (options || {}) as EventListenerOptions;
+    if (!event && typeof options === 'string')
+        event = options as string;
+    if (!event)
+        event = undefined;
+    if (!mixinId)
+        return event;
+    let ret = `${event}-mixin-${mixinId}`;
+    return ret;
+}
+
 // todo: storage should only go to host plugin
 const allowedEventInterfaces = new Set<string>([ScryptedInterface.ScryptedDevice, 'Logger', 'Storage'])
 
@@ -25,11 +37,7 @@ export class EventRegistry {
     }
 
     listenDevice(id: string, options: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
-        let { event } = (options || {}) as EventListenerOptions;
-        if (!event && typeof options === 'string')
-            event = options as string;
-        if (!event)
-            event = undefined;
+        let event = getMixinEventName(options)
         const token = `${id}#${event}`;
         let events = this.listeners[token];
         if (!events) {
@@ -44,23 +52,34 @@ export class EventRegistry {
         });
     }
 
-    notify(id: string|undefined, eventTime: number, eventInterface: string, property: string|undefined, value: any, changed?: boolean): boolean {
+    notify(id: string | undefined, eventTime: number, eventInterface: string, property: string | undefined, value: any, options?: {
+        changed?: boolean;
+        mixinId?: string;
+    }): boolean {
+        const { changed, mixinId } = options || {};
         // prevent property event noise
         if (property && !changed)
             return false;
 
         const eventDetails: EventDetails = {
-            eventId: Math.random().toString(),
-            changed,
+            eventId: undefined,
             eventInterface,
             eventTime,
             property,
+            mixinId,
         };
 
+        return this.notifyEventDetails(id, eventDetails, value);
+    }
+
+    notifyEventDetails(id: string | undefined, eventDetails: EventDetails, value: any, eventInterface?: string) {
+        eventDetails.eventId ||= Math.random().toString(36).substring(2);
+        eventInterface ||= eventDetails.eventInterface;
+
         // system listeners only get state changes.
         // there are many potentially noisy stateless events, like
         // object detection and settings changes.
-        if (property || allowedEventInterfaces.has(eventInterface)) {
+        if ((eventDetails.property && !eventDetails.mixinId) || allowedEventInterfaces.has(eventInterface)) {
             for (const event of this.systemListeners) {
                 event(id, eventDetails, value);
             }

package/src/media-helpers.ts

@@ -25,6 +25,9 @@ export function safeKillFFmpeg(cp: ChildProcess) {
 }
 
 export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forever?: boolean, storage?: Storage) {
+    if (!console)
+        return;
+
     const SCRYPTED_FFMPEG_NOISY = !!process.env.SCRYPTED_FFMPEG_NOISY || !!storage?.getItem('SCRYPTED_FFMPEG_NOISY');
 
     function logger(log: (str: string) => void): (buffer: Buffer) => void {
@@ -55,6 +58,8 @@ export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forev
 }
 
 export function safePrintFFmpegArguments(console: Console, args: string[]) {
+    if (!console)
+        return;
     const ret = [];
     let redactNext = false;
     for (const arg of args) {

package/src/mixin/mixin-cycle.ts

@@ -2,7 +2,7 @@ import { ScryptedInterfaceProperty } from "@scrypted/types";
 import { ScryptedRuntime } from "../runtime";
 import { getState } from "../state";
 
-function getMixins(scrypted: ScryptedRuntime, id: string) {
+export function getMixins(scrypted: ScryptedRuntime, id: string) {
     const pluginDevice = scrypted.findPluginDeviceById(id);
     if (!pluginDevice)
         return [];

package/src/plugin/plugin-api.ts

@@ -171,7 +171,11 @@ export interface PluginRemote {
     setSystemState(state: { [id: string]: { [property: string]: SystemDeviceState } }): Promise<void>;
     setNativeId(nativeId: ScryptedNativeId, id: string, storage: { [key: string]: any }): Promise<void>;
     updateDeviceState(id: string, state: { [property: string]: SystemDeviceState }): Promise<void>;
+    /**
+     * @deprecated
+     */
     notify(id: string, eventTime: number, eventInterface: string, property: string | undefined, value: SystemDeviceState | any, changed?: boolean): Promise<void>;
+    notify(id: string, eventDetails: EventDetails, eventData: SystemDeviceState | any): Promise<void>;
 
     ioEvent(id: string, event: string, message?: any): Promise<void>;
 

package/src/plugin/plugin-device.ts

@@ -56,23 +56,23 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
             // allow mixins in the process of being released to manage final
             // events, etc, before teardown.
             this.releasing.add(proxy);
-            mixinProvider?.releaseMixin(this.id, proxy);
+            mixinProvider?.releaseMixin(this.id, proxy).catch(() => { });
             await sleep(1000);
             this.releasing.delete(proxy);
         })().catch(() => { });
     }
 
-    async isMixin(id: string, mixinDevice: any) {
+    async getMixinProviderId(id: string, mixinDevice: any) {
         if (this.releasing.has(mixinDevice))
             return true;
         await this.scrypted.devices[id].handler.ensureProxy();
         for (const mixin of this.scrypted.devices[id].handler.mixinTable) {
             const { proxy } = await mixin.entry;
             if (proxy === mixinDevice) {
-                return true;
+                return mixin.mixinProviderId || id;
             }
         }
-        return false;
+        return undefined;
     }
 
     // should this be async?
@@ -260,7 +260,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
             const propertyInterfaces = getPropertyInterfaces(host.api.descriptors || ScryptedInterfaceDescriptors);
             // todo: remove this and pass the setter directly.
             const deviceState = await host.remote.createDeviceState(this.id,
-                async (property, value) => this.scrypted.stateManager.setPluginDeviceState(pluginDevice, property, value, propertyInterfaces[property]));
+                async (property, value) => this.scrypted.stateManager.setPluginDeviceStateFromMixin(pluginDevice, property, value, propertyInterfaces[property], mixinId));
             const mixinProxy = await mixinProvider.getMixin(wrappedProxy, previousInterfaces as ScryptedInterface[], deviceState);
             if (!mixinProxy)
                 throw new PluginError(`mixin provider ${mixinId} did not return mixin for ${this.id}`);
@@ -370,7 +370,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
                     const pluginDevice = this.scrypted.findPluginDeviceById(mixin.mixinProviderId || this.id);
                     const plugin = this.scrypted.plugins[pluginDevice.pluginId];
                     let methods = new Set<string>(getInterfaceMethods(ScryptedInterfaceDescriptors, entry.interfaces))
-                    if (plugin.api.descriptors)
+                    if (plugin?.api.descriptors)
                         methods = new Set<string>([...methods, ...getInterfaceMethods(plugin.api.descriptors, entry.interfaces)]);
                     entry.methods = methods;
                 }

package/src/plugin/plugin-host-api.ts

@@ -61,14 +61,20 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
             const { interfaces } = await tableEntry.entry;
             if (!interfaces.has(eventInterface))
                 throw new Error(`${mixinProvider._id} does not mixin ${eventInterface} for ${id}`);
+
+            this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
         }
         else {
             const mixin: object = nativeIdOrMixinDevice;
-            if (!await this.scrypted.devices[device._id]?.handler?.isMixin(id, mixin)) {
+            let mixinProviderId = await this.scrypted.devices[device._id]?.handler?.getMixinProviderId(id, mixin);
+            if (!mixinProviderId)
                 throw new Error(`${mixin} does not mixin ${eventInterface} for ${id}`);
-            }
+
+            if (mixinProviderId === true)
+                mixinProviderId = undefined;
+            // this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
+            this.scrypted.stateManager.notifyInterfaceEventFromMixin(device, eventInterface, eventData, mixinProviderId as string);
         }
-        this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
     }
 
     async getMediaManager(): Promise<MediaManager> {
@@ -100,7 +106,11 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async setState(nativeId: ScryptedNativeId, key: string, value: any) {
         checkProperty(key, value);
-        this.scrypted.stateManager.setPluginState(this.pluginId, nativeId, this.propertyInterfaces?.[key], key, value);
+        const { pluginId } = this;
+        const device = this.scrypted.findPluginDevice(pluginId, nativeId);
+        if (!device)
+            throw new Error(`device not found for plugin id ${pluginId} native id ${nativeId}`);
+        await this.scrypted.stateManager.setPluginDeviceStateFromMixin(device, key, value, this.propertyInterfaces?.[key], device._id);
     }
 
     async setStorage(nativeId: ScryptedNativeId, storage: { [key: string]: string }) {
@@ -136,7 +146,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any) {
         const plugin = this.scrypted.findPluginDevice(this.pluginId, nativeId);
-        this.scrypted.stateManager.notifyInterfaceEvent(plugin, eventInterface, eventData);
+        this.scrypted.stateManager.notifyInterfaceEventFromMixin(plugin, eventInterface, eventData, plugin._id);
     }
 
     async getDeviceById<T>(id: string): Promise<T & ScryptedDevice> {
@@ -146,11 +156,11 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         return this.manageListener(this.scrypted.stateManager.listen(callback));
     }
     async listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister> {
-        const device = this.scrypted.findPluginDeviceById(id);
-        if (device) {
-            const self = this.scrypted.findPluginDevice(this.pluginId);
-            this.scrypted.getDeviceLogger(self).log('i', `requested listen ${getState(device, ScryptedInterfaceProperty.name)} ${JSON.stringify(event)}`);
-        }
+        // const device = this.scrypted.findPluginDeviceById(id);
+        // if (device) {
+        //     const self = this.scrypted.findPluginDevice(this.pluginId);
+        //     this.scrypted.getDeviceLogger(self).log('i', `requested listen ${getState(device, ScryptedInterfaceProperty.name)} ${JSON.stringify(event)}`);
+        // }
         return this.manageListener(this.scrypted.stateManager.listenDevice(id, event, callback));
     }
 

package/src/plugin/plugin-lazy-remote.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, SystemDeviceState } from '@scrypted/types'
+import { EventDetails, ScryptedNativeId, SystemDeviceState } from '@scrypted/types'
 import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 
 /**
@@ -42,7 +42,9 @@ import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
         }
         return this.remote.updateDeviceState(id, state);
     }
-    async notify(id: string, eventTime: number, eventInterface: string, property: string, propertyState: SystemDeviceState, changed?: boolean): Promise<void> {
+    // TODO: deprecate/clean up this signature
+    // 12/30/2022
+    async notify(id: string, eventTimeOrDetails: number| EventDetails, eventInterfaceOrData: string | SystemDeviceState | any, property?: string, value?: SystemDeviceState | any, changed?: boolean) {
         try {
             if (!this.remote)
                 await this.remoteReadyPromise;
@@ -50,7 +52,7 @@ import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
         catch (e) {
             return;
         }
-        return this.remote.notify(id, eventTime, eventInterface, property, propertyState, changed);
+        return this.remote.notify(id, eventTimeOrDetails as any, eventInterfaceOrData, property, value, changed);
     }
     async ioEvent(id: string, event: string, message?: any): Promise<void> {
         if (!this.remote)

package/src/plugin/plugin-remote.ts

@@ -1,4 +1,4 @@
-import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointManager, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
+import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointManager, EventDetails, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { AccessControls } from './acl';
 import { BufferSerializer } from './buffer-serializer';
@@ -175,8 +175,6 @@ class DeviceStateProxyHandler implements ProxyHandler<any> {
         checkProperty(p.toString(), value);
         const now = Date.now();
         this.deviceManager.systemManager.state[this.id][p as string] = {
-            lastEventTime: now,
-            stateTime: now,
             value,
         };
         this.setState(p.toString(), value);
@@ -367,7 +365,7 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
 
         const accessControls: AccessControls = peer.tags.acl;
 
-        const getAccessControlDeviceState = (id: string, state?:  { [property: string]: SystemDeviceState } ) => {
+        const getAccessControlDeviceState = (id: string, state?: { [property: string]: SystemDeviceState }) => {
             state = state || getSystemState()[id];
             if (accessControls && state) {
                 state = Object.assign({}, state);
@@ -420,11 +418,11 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
                 return;
             }
 
-            if (eventDetails.property) {
-                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, getSystemState()[id]?.[eventDetails.property], eventDetails.changed).catch(() => { });
+            if (eventDetails.property && !eventDetails.mixinId) {
+                remote.notify(id, eventDetails, getSystemState()[id]?.[eventDetails.property]).catch(() => { });
             }
             else {
-                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, eventData, eventDetails.changed).catch(() => { });
+                remote.notify(id, eventDetails, eventData).catch(() => { });
             }
         });
 
@@ -567,26 +565,48 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             async updateDeviceState(id: string, state: { [property: string]: SystemDeviceState }) {
                 if (!state) {
                     delete systemManager.state[id];
-                    systemManager.events.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
+                    systemManager.events.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, { changed: true });
                 }
                 else {
                     systemManager.state[id] = state;
-                    systemManager.events.notify(id, undefined, ScryptedInterface.ScryptedDevice, undefined, state, true);
+                    systemManager.events.notify(id, undefined, ScryptedInterface.ScryptedDevice, undefined, state, { changed: true });
                 }
             },
 
-            async notify(id: string, eventTime: number, eventInterface: string, property: string, value: SystemDeviceState | any, changed?: boolean) {
-                if (property) {
-                    const state = systemManager.state?.[id];
-                    if (!state) {
-                        log.w(`state not found for ${id}`);
-                        return;
+            async notify(id: string, eventTimeOrDetails: number| EventDetails, eventInterfaceOrData: string | SystemDeviceState | any, property?: string, value?: SystemDeviceState | any, changed?: boolean) {
+                if (typeof eventTimeOrDetails === 'number') {
+                    // TODO: remove legacy code path
+                    // 12/30/2022
+                    const eventTime = eventTimeOrDetails as number;
+                    const eventInterface = eventInterfaceOrData as string;
+                    if (property) {
+                        const state = systemManager.state?.[id];
+                        if (!state) {
+                            log.w(`state not found for ${id}`);
+                            return;
+                        }
+                        state[property] = value;
+                        systemManager.events.notify(id, eventTime, eventInterface, property, value.value, { changed });
+                    }
+                    else {
+                        systemManager.events.notify(id, eventTime, eventInterface, property, value, { changed });
                     }
-                    state[property] = value;
-                    systemManager.events.notify(id, eventTime, eventInterface, property, value.value, changed);
                 }
                 else {
-                    systemManager.events.notify(id, eventTime, eventInterface, property, value, changed);
+                    const eventDetails = eventTimeOrDetails as EventDetails;
+                    const eventData = eventInterfaceOrData as any;
+                    if (eventDetails.property && !eventDetails.mixinId) {
+                        const state = systemManager.state?.[id];
+                        if (!state) {
+                            log.w(`state not found for ${id}`);
+                            return;
+                        }
+                        state[eventDetails.property] = eventData;
+                        systemManager.events.notifyEventDetails(id, eventDetails, eventData.value);
+                    }
+                    else {
+                        systemManager.events.notifyEventDetails(id, eventDetails, eventData);
+                    }
                 }
             },
 

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/runtime.ts

@@ -20,7 +20,7 @@ import { getDisplayName, getDisplayRoom, getDisplayType, getProvidedNameOrDefaul
 import { IOServer } from './io';
 import { Level } from './level';
 import { LogEntry, Logger, makeAlertId } from './logger';
-import { hasMixinCycle } from './mixin/mixin-cycle';
+import { getMixins, hasMixinCycle } from './mixin/mixin-cycle';
 import { AccessControls } from './plugin/acl';
 import { PluginDebug } from './plugin/plugin-debug';
 import { PluginDeviceProxyHandler } from './plugin/plugin-device';
@@ -652,10 +652,25 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
         this.setupPluginHostAutoRestart(pluginHost);
         this.plugins[pluginId] = pluginHost;
 
+        const pluginDeviceSet = new Set<string>();
         for (const pluginDevice of pluginDevices) {
+            if (pluginDeviceSet.has(pluginDevice._id))
+                continue;
+            pluginDeviceSet.add(pluginDevice._id);
             this.getDevice(pluginDevice._id)?.probe().catch(() => { });
         }
 
+        for (const pluginDevice of Object.values(this.pluginDevices)) {
+            const { _id } = pluginDevice;
+            if (pluginDeviceSet.has(_id))
+                continue;
+            for (const mixinId of getMixins(this, _id)) {
+                if (pluginDeviceSet.has(mixinId)) {
+                    this.getDevice(_id)?.probe().catch(() => { });
+                }
+            }
+        }
+
         return pluginHost;
     }
 

package/src/scrypted-server-main.ts

@@ -161,13 +161,6 @@ async function start() {
         next();
     })
 
-    app.options('*', (req, res) => {
-        // add more?
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');
-        res.send(200);
-    });
-
     const authSalt = crypto.randomBytes(16);
     const createAuthorizationToken = (login_user_token: string) => {
         const salted = login_user_token + authSalt;

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;
 }