add rpc system to improve ipc

backend/src/ConfigStorage.ts

@@ -2,10 +2,8 @@ import * as FileAsync from 'lowdb/adapters/FileAsync'
 import * as fs from 'fs-extra'
 import * as lowdb from 'lowdb'
 import * as path from 'path'
-import { backendEvents } from '../../events'
+import { backendRpc } from '../../events'
 import {
-  makeStorageAcknowledgementEvent,
-  makeStorageResponseEvent,
   storageClearEvent,
   storageLoadEvent,
   storageStoreEvent,
@@ -32,56 +30,26 @@ export default class ConfigStorage {
   }
 
   public async init() {
-    backendEvents.subscribe(storageStoreEvent, async event => {
-      const ack = makeStorageAcknowledgementEvent(event.transactionId)
-      try {
-        const db = await this.getDb()
-        await db.set(event.store, event.data).write()
-        backendEvents.emit(ack, undefined)
-      } catch (error) {
-        backendEvents.emit(ack, {
-          error,
-          transactionId: event.transactionId,
-          store: event.store,
-        })
-        throw error
+    backendRpc.on(storageStoreEvent, async event => {
+      const db = await this.getDb()
+      await db.set(event.store, event.data).write()
+      return
+    })
+
+    backendRpc.on(storageLoadEvent, async event => {
+      const db = await this.getDb()
+      const data = await db.get(event.store).value()
+      return {
+        data,
+        store: event.store,
       }
     })
 
-    backendEvents.subscribe(storageLoadEvent, async event => {
-      const responseEvent = makeStorageResponseEvent(event.transactionId)
-      try {
-        const db = await this.getDb()
-        const data = await db.get(event.store).value()
-        backendEvents.emit(responseEvent, {
-          data,
-          transactionId: event.transactionId,
-          store: event.store,
-        })
-      } catch (error) {
-        backendEvents.emit(responseEvent, {
-          error,
-          transactionId: event.transactionId,
-          store: event.store,
-        })
-        throw error
-      }
-    })
-
-    backendEvents.subscribe(storageClearEvent, async event => {
-      try {
-        const db = await this.getDb()
-        const keys = await db.keys().value()
-        for (const key of keys) {
-          await db.unset(key).write()
-        }
-        backendEvents.emit(makeStorageAcknowledgementEvent(event.transactionId), undefined)
-      } catch (error) {
-        backendEvents.emit(makeStorageAcknowledgementEvent(event.transactionId), {
-          error,
-          transactionId: event.transactionId,
-        })
-        throw error
+    backendRpc.on(storageClearEvent, async event => {
+      const db = await this.getDb()
+      const keys = await db.keys().value()
+      for (const key of keys) {
+        await db.unset(key).write()
       }
     })
   }

backend/src/Model/Tree.ts

@@ -1,6 +1,6 @@
 import { ChangeBuffer } from './ChangeBuffer'
 import { Destroyable } from './Destroyable'
-import { EventBusInterface, EventDispatcher, makeConnectionMessageEvent, MqttMessage } from '../../../events'
+import { EventDispatcher, makeConnectionMessageEvent, MqttMessage, EventBusInterface } from '../../../events'
 import { TreeNode } from './'
 import { TreeNodeFactory } from './TreeNodeFactory'
 
@@ -31,7 +31,7 @@ export class Tree<ViewModel extends Destroyable> extends TreeNode<ViewModel> {
       if (!this.paused && this.applyChangesHasCompleted) {
         this.applyChangesHasCompleted = false
         if ((window as any).requestIdleCallback) {
-          ;(window as any).requestIdleCallback(() => this.applyUnmergedChanges(), { timeout: 500 })
+          ; (window as any).requestIdleCallback(() => this.applyUnmergedChanges(), { timeout: 500 })
         } else {
           this.applyUnmergedChanges()
         }