@flexem/fc-gui 3.0.0-alpha.16 → 3.0.0-alpha.160

package/remote/communication/variable/remote-variable-communicator.js

@@ -1,215 +1,395 @@
-import { each, remove, uniq } from 'lodash';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { StringifyingMap } from '../../../core';
-export class RemoteVariableCommunicator {
-    constructor(remoteVariableProtocol, logger) {
-        this.remoteVariableProtocol = remoteVariableProtocol;
-        this.logger = logger;
-        this.observers = new Map();
-        this.appIdVariablesMap = new Map();
-        this.variableStateObservers = new Map();
-        this.variableStateCache = new Map();
-        this.variableValueCache = new StringifyingMap(k => JSON.stringify(k));
-        this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
-            const variableNamesToStart = [];
-            this.variableStateObservers.forEach((__, variableName) => {
-                variableNamesToStart.push(variableName);
-            });
-            this.remoteVariableProtocol.subscribeVariableStates(variableNamesToStart);
-            this.appIdVariablesMap.forEach((variableNames, appId) => {
-                this.remoteVariableProtocol.tryOpenVariables(variableNames, appId);
-            });
-        });
-        this.doVariableStatesChanged();
-        this.doVariableValuesChanged();
-    }
-    doVariableValuesChanged() {
-        if (this.variableValuesChangedSubscription !== undefined) {
-            this.variableValuesChangedSubscription.unsubscribe();
-        }
-        this.variableValuesChangedSubscription =
-            this.remoteVariableProtocol.variableValuesChanged.subscribe((values) => {
-                each(values, variableValue => {
-                    const variableName = variableValue.variableName;
-                    this.variableValueCache.set(variableName, variableValue);
-                    if (this.observers.has(variableName)) {
-                        each(this.observers.get(variableName), ob => {
-                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
-                            ob.next([variableValue]);
-                        });
-                    }
-                });
-            });
-    }
-    doVariableStatesChanged() {
-        if (this.variableStatesChangedSubscription !== undefined) {
-            this.variableStatesChangedSubscription.unsubscribe();
-        }
-        this.variableStatesChangedSubscription =
-            this.remoteVariableProtocol.variableStatesChanged.subscribe((states) => {
-                each(states, state => {
-                    const variableName = state.variableName;
-                    this.variableStateCache.set(variableName, state);
-                    if (this.variableStateObservers.has(variableName)) {
-                        each(this.variableStateObservers.get(variableName), ob => {
-                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
-                            ob.next([state]);
-                        });
-                    }
-                });
-            });
-    }
-    subscribeVariableStates(variableNames) {
-        return new Observable(observer => {
-            let variableNamesToStart = [];
-            each(variableNames, variableName => {
-                if (!this.variableStateObservers.has(variableName)) {
-                    this.variableStateObservers.set(variableName, []);
-                    variableNamesToStart.push(variableName);
-                }
-                else {
-                    if (this.variableStateCache.has(variableName)) {
-                        observer.next([this.variableStateCache.get(variableName)]);
-                    }
-                }
-                this.variableStateObservers.get(variableName).push(observer);
-            });
-            variableNamesToStart = uniq(variableNamesToStart);
-            if (variableNamesToStart && variableNamesToStart.length > 0) {
-                if (!this.variableStatesToBeOpened) {
-                    this.variableStatesToBeOpened = [];
-                    setTimeout(() => {
-                        this.remoteVariableProtocol.subscribeVariableStates(this.variableStatesToBeOpened);
-                        delete this.variableStatesToBeOpened;
-                    });
-                }
-                this.variableStatesToBeOpened.push(...variableNamesToStart);
-            }
-            return () => {
-                const stopedVariableStates = [];
-                each(variableNames, variableName => {
-                    const obs = this.variableStateObservers.get(variableName);
-                    if (obs) {
-                        remove(obs, item => item === observer);
-                        if (obs.length <= 0) {
-                            this.variableStateObservers.delete(variableName);
-                            stopedVariableStates.push(variableName);
-                        }
-                    }
-                });
-                if (!stopedVariableStates.length) {
-                    return;
-                }
-                if (!this.variableStatesToBeClosed) {
-                    this.variableStatesToBeClosed = [];
-                    setTimeout(() => {
-                        this.remoteVariableProtocol.unsubscribeVariableStates(this.variableStatesToBeClosed);
-                        delete this.variableStatesToBeClosed;
-                    });
-                }
-                this.variableStatesToBeClosed.push(...stopedVariableStates);
-            };
-        });
-    }
-    subscribeVariableState(variableName) {
-        return this.subscribeVariableStates([variableName]).pipe(map(values => values[0]));
-    }
-    openVariables(variableNames, appId = '') {
-        return new Observable(observer => {
-            let variablesToStart = [];
-            each(variableNames, variableName => {
-                if (variableName) {
-                    if (!this.observers.has(variableName)) {
-                        this.observers.set(variableName, []);
-                        variablesToStart.push(variableName);
-                    }
-                    else {
-                        if (this.variableValueCache.has(variableName)) {
-                            observer.next([this.variableValueCache.get(variableName)]);
-                        }
-                    }
-                    this.observers.get(variableName).push(observer);
-                    if (!this.appIdVariablesMap.get(appId)) {
-                        this.appIdVariablesMap.set(appId, []);
-                    }
-                    else {
-                        if (this.appIdVariablesMap.get(appId).indexOf(variableName) === -1) {
-                            this.appIdVariablesMap.get(appId).push(variableName);
-                        }
-                    }
-                }
-            });
-            variablesToStart = uniq(variablesToStart);
-            if (variablesToStart && variablesToStart.length > 0) {
-                if (!this.variablesToBeOpened) {
-                    this.variablesToBeOpened = [];
-                    setTimeout(() => {
-                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened, appId);
-                        delete this.variablesToBeOpened;
-                    });
-                }
-                this.variablesToBeOpened.push(...variablesToStart);
-            }
-            return () => {
-                const stopedDataMonitorPoints = [];
-                each(variableNames, variableName => {
-                    const obs = this.observers.get(variableName);
-                    if (obs) {
-                        remove(obs, item => item === observer);
-                        if (obs.length <= 0) {
-                            this.observers.delete(variableName);
-                            stopedDataMonitorPoints.push(variableName);
-                        }
-                    }
-                });
-                if (!stopedDataMonitorPoints.length) {
-                    return;
-                }
-                if (!this.variablesToBeClosed) {
-                    this.variablesToBeClosed = [];
-                    setTimeout(() => {
-                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed, appId);
-                        delete this.variablesToBeClosed;
-                    });
-                }
-                this.variablesToBeClosed.push(...stopedDataMonitorPoints);
-            };
-        });
-    }
-    openVariable(variableName, appId = '') {
-        if (!variableName) {
-            return;
-        }
-        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
-    }
-    write(variableName, value) {
-        if (!variableName) {
-            return;
-        }
-        this.remoteVariableProtocol.writeVariable(variableName, value);
-        return new Observable(__ => {
-            /* do nothing right now, if want value change immediately, can use this code below:
-              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
-        });
-    }
-    writeWordByBit(variableName, index, value) {
-        if (!variableName) {
-            return;
-        }
-        this.remoteVariableProtocol.writeVariableWordByBit(variableName, index, value);
-        return new Observable(__ => {
-            /* do nothing right now, if want value change immediately, can use this code below:
-              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
-        });
-    }
-    dispose() {
-        // TODO调用所有的ob.complete()。
-        this.connectedSubscription.unsubscribe();
-        this.variableStatesChangedSubscription.unsubscribe();
-        this.variableValuesChangedSubscription.unsubscribe();
-        if (this.logger && this.logger.isDebugEnabled()) {
-            this.logger.debug('[VariableCommunicator] RemoteVariableCommunicator disposed.');
-        }
-    }
-}
+import { each, remove, uniq } from 'lodash';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { VariableStateEnum } from '../../../communication';
+import { StringifyingMap } from '../../../core';
+import { GuiFeatureConfig } from '../../../config';
+export class RemoteVariableCommunicator {
+    constructor(remoteVariableProtocol, logger) {
+        this.remoteVariableProtocol = remoteVariableProtocol;
+        this.logger = logger;
+        this.observers = new Map();
+        this.appIdVariablesMap = new Map();
+        this.variableStateObservers = new Map();
+        this.variableStateCache = new Map();
+        this.alarmObservers = [];
+        // 系统变量处理器
+        this.systemVariableHandlers = new Map();
+        // 预加载的离线变量最新值缓存（组态加载时一次性填充，推送后即删除）
+        this.offlineValueCache = new Map();
+        this.variableValueCache = new StringifyingMap(k => JSON.stringify(k));
+        this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
+            const variableNamesToStart = [];
+            this.variableStateObservers.forEach((__, variableName) => {
+                variableNamesToStart.push(variableName);
+            });
+            this.remoteVariableProtocol.subscribeVariableStates(variableNamesToStart);
+            this.appIdVariablesMap.forEach((variableNames, appId) => {
+                this.remoteVariableProtocol.tryOpenVariables(variableNames, appId);
+            });
+        });
+        this.doVariableStatesChanged();
+        this.doVariableValuesChanged();
+        this.doVirtualDeviceStatesChanged();
+        this.doAlarmChanged();
+    }
+    doAlarmChanged() {
+        if (this.alarmChangedSubscription !== undefined) {
+            this.alarmChangedSubscription.unsubscribe();
+        }
+        this.alarmChangedSubscription = this.remoteVariableProtocol.virtualDeviceAlarmsChanged.subscribe((alarms) => {
+            each(this.alarmObservers, ob => {
+                ob.next(alarms);
+            });
+        });
+    }
+    doVariableValuesChanged() {
+        if (this.variableValuesChangedSubscription !== undefined) {
+            this.variableValuesChangedSubscription.unsubscribe();
+        }
+        this.variableValuesChangedSubscription =
+            this.remoteVariableProtocol.variableValuesChanged.subscribe((values) => {
+                each(values, variableValue => {
+                    const variableName = variableValue.variableName;
+                    this.variableValueCache.set(variableName, variableValue);
+                    if (this.observers.has(variableName)) {
+                        each(this.observers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([variableValue]);
+                        });
+                    }
+                });
+            });
+    }
+    doVirtualDeviceStatesChanged() {
+        if (this.virtualDeviceStatesChangedSubscription !== undefined) {
+            this.virtualDeviceStatesChangedSubscription.unsubscribe();
+        }
+        this.virtualDeviceStatesChangedSubscription =
+            this.remoteVariableProtocol.virtualDeviceStatesChanged.subscribe((deviceStates) => {
+                each(deviceStates, deviceState => {
+                    const variableName = '设备状态';
+                    this.variableValueCache.set(variableName, deviceState);
+                    const data = Object.assign(Object.assign({}, deviceState), { systemName: '设备状态' });
+                    if (this.observers.has(variableName)) {
+                        each(this.observers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([data]);
+                        });
+                    }
+                });
+            });
+    }
+    doVariableStatesChanged() {
+        if (this.variableStatesChangedSubscription !== undefined) {
+            this.variableStatesChangedSubscription.unsubscribe();
+        }
+        this.variableStatesChangedSubscription =
+            this.remoteVariableProtocol.variableStatesChanged.subscribe((states) => {
+                each(states, state => {
+                    const variableName = state.variableName;
+                    this.variableStateCache.set(variableName, state);
+                    if (this.variableStateObservers.has(variableName)) {
+                        each(this.variableStateObservers.get(variableName), ob => {
+                            ob.next([state]);
+                        });
+                    }
+                    // 离线时推送最后已知值给值订阅者
+                    if (GuiFeatureConfig.isOfflineDisplayEnabled && state.state === VariableStateEnum.Offline) {
+                        let cachedValue;
+                        // 优先用最后一次收到的值（可能是在线时推送的），覆盖所有切页/重连场景
+                        if (this.variableValueCache.has(variableName)) {
+                            cachedValue = this.variableValueCache.get(variableName).value;
+                        }
+                        else if (this.offlineValueCache.has(variableName)) {
+                            // 兜底：变量从未收到过值，用预加载的离线值
+                            cachedValue = this.offlineValueCache.get(variableName);
+                        }
+                        if (cachedValue !== null && cachedValue !== undefined) {
+                            const variableValue = {
+                                variableName,
+                                value: cachedValue,
+                                state: VariableStateEnum.Offline
+                            };
+                            this.variableValueCache.set(variableName, variableValue);
+                            if (this.observers.has(variableName)) {
+                                each(this.observers.get(variableName), ob => {
+                                    ob.next([variableValue]);
+                                });
+                            }
+                        }
+                    }
+                });
+            });
+    }
+    /**
+     * 预填充离线变量值缓存，由 GuiContext 在组态加载时一次性调用。
+     * 若状态推送早于接口返回，变量已在 Offline 状态，则直接推送；
+     * 否则缓存等待状态事件到来时推送。
+     */
+    setOfflineValueCache(variableName, value) {
+        if (!GuiFeatureConfig.isOfflineDisplayEnabled) {
+            return;
+        }
+        if (value === null || value === undefined) {
+            return;
+        }
+        const cachedState = this.variableStateCache.get(variableName);
+        if (cachedState && cachedState.state === VariableStateEnum.Offline) {
+            // 状态已推送过，直接补推值给订阅者
+            const variableValue = {
+                variableName,
+                value,
+                state: VariableStateEnum.Offline
+            };
+            this.variableValueCache.set(variableName, variableValue);
+            if (this.observers.has(variableName)) {
+                each(this.observers.get(variableName), ob => {
+                    ob.next([variableValue]);
+                });
+            }
+        }
+        else {
+            // 状态还未推送，先缓存，等待状态事件
+            this.offlineValueCache.set(variableName, value);
+        }
+    }
+    subscribeVariableStates(variableNames) {
+        return new Observable(observer => {
+            let variableNamesToStart = [];
+            each(variableNames, variableName => {
+                if (!this.variableStateObservers.has(variableName)) {
+                    this.variableStateObservers.set(variableName, []);
+                    variableNamesToStart.push(variableName);
+                }
+                else {
+                    if (this.variableStateCache.has(variableName)) {
+                        observer.next([this.variableStateCache.get(variableName)]);
+                    }
+                }
+                this.variableStateObservers.get(variableName).push(observer);
+            });
+            variableNamesToStart = uniq(variableNamesToStart);
+            if (variableNamesToStart && variableNamesToStart.length > 0) {
+                if (!this.variableStatesToBeOpened) {
+                    this.variableStatesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.subscribeVariableStates(this.variableStatesToBeOpened);
+                        delete this.variableStatesToBeOpened;
+                    });
+                }
+                this.variableStatesToBeOpened.push(...variableNamesToStart);
+            }
+            return () => {
+                const stopedVariableStates = [];
+                each(variableNames, variableName => {
+                    const obs = this.variableStateObservers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.variableStateObservers.delete(variableName);
+                            stopedVariableStates.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedVariableStates.length) {
+                    return;
+                }
+                if (!this.variableStatesToBeClosed) {
+                    this.variableStatesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.unsubscribeVariableStates(this.variableStatesToBeClosed);
+                        delete this.variableStatesToBeClosed;
+                    });
+                }
+                this.variableStatesToBeClosed.push(...stopedVariableStates);
+            };
+        });
+    }
+    subscribeVariableState(variableName) {
+        return this.subscribeVariableStates([variableName]).pipe(map(values => values[0]));
+    }
+    requestVirtualDeviceState() {
+        return this.remoteVariableProtocol.requestVirtualDeviceState();
+    }
+    openVariables(variableNames, appId = '') {
+        return new Observable(observer => {
+            let variablesToStart = [];
+            each(variableNames, variableName => {
+                if (variableName) {
+                    if (!this.observers.has(variableName)) {
+                        this.observers.set(variableName, []);
+                        variablesToStart.push(variableName);
+                    }
+                    else {
+                        if (this.variableValueCache.has(variableName)) {
+                            observer.next([this.variableValueCache.get(variableName)]);
+                        }
+                    }
+                    this.observers.get(variableName).push(observer);
+                    if (!this.appIdVariablesMap.get(appId)) {
+                        this.appIdVariablesMap.set(appId, []);
+                    }
+                    else {
+                        if (this.appIdVariablesMap.get(appId).indexOf(variableName) === -1) {
+                            this.appIdVariablesMap.get(appId).push(variableName);
+                        }
+                    }
+                }
+            });
+            // 过滤掉系统变量，它们不需要通过SignalR订阅
+            const normalVariables = variablesToStart.filter(v => !this.systemVariableHandlers.has(v));
+            const systemVariables = variablesToStart.filter(v => this.systemVariableHandlers.has(v));
+            // 处理系统变量的初始值
+            systemVariables.forEach(variableName => {
+                const handler = this.systemVariableHandlers.get(variableName);
+                if (handler && handler.getValue) {
+                    void handler.getValue().then(value => {
+                        const variableValue = {
+                            variableName: variableName,
+                            value: value,
+                            state: 1 // Normal state
+                        };
+                        this.variableValueCache.set(variableName, variableValue);
+                        if (this.observers.has(variableName)) {
+                            each(this.observers.get(variableName), ob => {
+                                ob.next([variableValue]);
+                            });
+                        }
+                    }).catch(error => {
+                        if (this.logger) {
+                            this.logger.error(`[RemoteVariableCommunicator] Failed to get system variable "${variableName}" value:`, error);
+                        }
+                    });
+                }
+            });
+            variablesToStart = uniq(normalVariables);
+            if (variablesToStart && variablesToStart.length > 0) {
+                if (!this.variablesToBeOpened) {
+                    this.variablesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened, appId);
+                        delete this.variablesToBeOpened;
+                    });
+                }
+                this.variablesToBeOpened.push(...variablesToStart);
+            }
+            return () => {
+                const stopedDataMonitorPoints = [];
+                each(variableNames, variableName => {
+                    const obs = this.observers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.observers.delete(variableName);
+                            stopedDataMonitorPoints.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedDataMonitorPoints.length) {
+                    return;
+                }
+                if (!this.variablesToBeClosed) {
+                    this.variablesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed, appId);
+                        delete this.variablesToBeClosed;
+                    });
+                }
+                this.variablesToBeClosed.push(...stopedDataMonitorPoints);
+            };
+        });
+    }
+    openVariable(variableName, appId = '') {
+        if (!variableName) {
+            return;
+        }
+        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
+    }
+    write(variableName, value) {
+        if (!variableName) {
+            return new Observable(observer => {
+                observer.complete();
+            });
+        }
+        // 检查是否为系统变量
+        if (this.systemVariableHandlers.has(variableName)) {
+            const handler = this.systemVariableHandlers.get(variableName);
+            // 调用系统变量的setValue处理器
+            void handler.setValue(value).catch(error => {
+                if (this.logger) {
+                    this.logger.error('[RemoteVariableCommunicator] Failed to set system variable value:', error);
+                }
+            });
+            return new Observable(__ => {
+                /* 系统变量通过自己的机制通知变化 */
+            });
+        }
+        // 普通变量通过SignalR写入
+        this.remoteVariableProtocol.writeVariable(variableName, value);
+        return new Observable(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
+        });
+    }
+    writeWordByBit(variableName, index, value) {
+        if (!variableName) {
+            return;
+        }
+        this.remoteVariableProtocol.writeVariableWordByBit(variableName, index, value);
+        return new Observable(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
+        });
+    }
+    subscribeUserDeviceAlarms(appId = '') {
+        return new Observable(observer => {
+            this.alarmObservers.push(observer);
+            this.remoteVariableProtocol.subscribeVirtualDeviceAlarms(appId);
+            return () => {
+                this.remoteVariableProtocol.unsubscribeVirtualDeviceAlarms(appId);
+            };
+        });
+    }
+    /**
+     * 注册系统变量处理器
+     * @param variableName 变量名（如"当前语种ID"）
+     * @param getValue 获取值的函数
+     * @param setValue 设置值的函数
+     */
+    registerSystemVariableHandler(variableName, getValue, setValue) {
+        this.systemVariableHandlers.set(variableName, { getValue, setValue });
+    }
+    /**
+     * 通知系统变量值变化
+     * 用于在系统变量值改变时通知所有订阅者
+     * @param variableName 变量名
+     * @param value 新值
+     */
+    notifySystemVariableChange(variableName, value) {
+        const variableValue = {
+            variableName: variableName,
+            value: value,
+            state: 1 // Normal state
+        };
+        // 更新缓存
+        this.variableValueCache.set(variableName, variableValue);
+        // 通知所有订阅者
+        if (this.observers.has(variableName)) {
+            each(this.observers.get(variableName), ob => {
+                ob.next([variableValue]);
+            });
+        }
+    }
+    dispose() {
+        // TODO调用所有的ob.complete()。
+        this.connectedSubscription.unsubscribe();
+        this.variableStatesChangedSubscription.unsubscribe();
+        this.variableValuesChangedSubscription.unsubscribe();
+        this.virtualDeviceStatesChangedSubscription.unsubscribe();
+        this.alarmChangedSubscription.unsubscribe();
+        if (this.logger && this.logger.isDebugEnabled()) {
+            this.logger.debug('[VariableCommunicator] RemoteVariableCommunicator disposed.');
+        }
+    }
+}

package/remote/communication/variable/remote-variable-communicator.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"RemoteVariableCommunicator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-variable-protocol","name":"RemoteVariableProtocol","line":24,"character":57},{"__symbolic":"reference","module":"../../../logger","name":"LoggerService","line":24,"character":106}]}],"doVariableValuesChanged":[{"__symbolic":"method"}],"doVariableStatesChanged":[{"__symbolic":"method"}],"subscribeVariableStates":[{"__symbolic":"method"}],"subscribeVariableState":[{"__symbolic":"method"}],"openVariables":[{"__symbolic":"method"}],"openVariable":[{"__symbolic":"method"}],"write":[{"__symbolic":"method"}],"writeWordByBit":[{"__symbolic":"method"}],"dispose":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"RemoteVariableCommunicator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-variable-protocol","name":"RemoteVariableProtocol","line":38,"character":57},{"__symbolic":"reference","module":"../../../logger","name":"LoggerService","line":38,"character":106}]}],"doAlarmChanged":[{"__symbolic":"method"}],"doVariableValuesChanged":[{"__symbolic":"method"}],"doVirtualDeviceStatesChanged":[{"__symbolic":"method"}],"doVariableStatesChanged":[{"__symbolic":"method"}],"setOfflineValueCache":[{"__symbolic":"method"}],"subscribeVariableStates":[{"__symbolic":"method"}],"subscribeVariableState":[{"__symbolic":"method"}],"requestVirtualDeviceState":[{"__symbolic":"method"}],"openVariables":[{"__symbolic":"method"}],"openVariable":[{"__symbolic":"method"}],"write":[{"__symbolic":"method"}],"writeWordByBit":[{"__symbolic":"method"}],"subscribeUserDeviceAlarms":[{"__symbolic":"method"}],"registerSystemVariableHandler":[{"__symbolic":"method"}],"notifySystemVariableChange":[{"__symbolic":"method"}],"dispose":[{"__symbolic":"method"}]}}}}]