fix(ibernation): avoid token expiration after suspend (#54)

Author: therockerline

.eslintrc.cjs

@@ -1,15 +1,51 @@
 module.exports = {
+  env: {
+    browser: true,
+    es2021: true,
+    jest: true
+  },
   extends: [
     'eslint:recommended',
     'plugin:react/recommended',
     'plugin:react/jsx-runtime',
     '@electron-toolkit/eslint-config-ts/recommended',
-    '@electron-toolkit/eslint-config-prettier'
+    '@electron-toolkit/eslint-config-prettier',
+    'eslint:recommended',
+    'plugin:react/recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier',
+    'react-app',
+    'react-app/jest'
   ],
   rules: {
     // disable the rule for all files
+    'no-prototype-builtins': 'off',
+    'no-case-declarations': 'off',
+    'no-useless-escape': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/no-unused-vars': 'warn',
-    '@typescript-eslint/no-explicit-any': 'warn'
+    '@typescript-eslint/no-explicit-any': 'warn',
+    '@typescript-eslint/no-this-alias': 'warn',
+    'react/react-in-jsx-scope': 'off',
+    camelcase: 'error',
+    'spaced-comment': 'error',
+    quotes: ['error', 'single'],
+    'no-duplicate-imports': 'error',
+    'react/display-name': false,
+    'import/no-anonymous-default-export': 'off'
+  },
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaFeatures: {
+      jsx: true
+    },
+    ecmaVersion: 'latest',
+    sourceType: 'module'
+  },
+  plugins: ['react', 'react-hooks', '@typescript-eslint', 'prettier'],
+  settings: {
+    'import/resolver': {
+      typescript: {}
+    }
   }
 }

.prettierrc.yaml

@@ -1,4 +1,6 @@
 singleQuote: true
 semi: false
-printWidth: 100
-trailingComma: none
+tabWidth: 2
+trailingComma: all
+jsxSingleQuote: true
+bracketSpacing: true

.vscode/launch.json

@@ -33,7 +33,8 @@
       "runtimeArgs": [
         "--sourcemap",
         "--",
-        "DEV=true"
+        "DEV=true",
+        "DEBUG=false"
       ],
       "env": {
         "REMOTE_DEBUGGING_PORT": "9222",

electron-builder.yml

@@ -1,13 +1,16 @@
 appId: 'com.nethesis.nethlink.app'
 productName: 'NethLink'
-copyright: 'prova copyright'
+copyright: 'copyright'
 afterSign: electron-builder-notarize
 electronLanguages:
   - en
   - en_US
   - en_UK
+  - en-US
+  - en-UK
   - it
   - it_IT
+  - it-IT
 directories:
   buildResources: build
 files:

src/main/classes/controllers/AccountController.ts

@@ -47,7 +47,10 @@ export class AccountController {
       },
       account: undefined,
       theme: store.store.theme,
-      connection: store.store.connection || false
+      connection: store.store.connection || false,
+      accountStatus: store.store.accountStatus || 'offline',
+      isCallsEnabled: store.store.isCallsEnabled || false,
+      lastDevice: store.store.lastDevice || undefined
     }, 'logout')
     store.saveToDisk()
   }
@@ -116,7 +119,10 @@ export class AccountController {
           type: account.data.default_device.type as AvailableDevices,
           id: account.data.default_device.id,
         } : undefined,
-        connection: store.store.connection || false
+        connection: store.store.connection || false,
+        accountStatus: store.store.accountStatus || 'offline',
+        isCallsEnabled: store.store.isCallsEnabled || false,
+        lastDevice: store.store.lastDevice || undefined
       }, 'saveLoggedAccount')
       store.saveToDisk()
       return account
@@ -176,7 +182,7 @@ export class AccountController {
 
   setAccountNethLinkBounds(nethlinkBounds: Electron.Rectangle | undefined): void {
     const account = store.store.account
-    Log.info('MAIN PRESENCE BACK', account?.data?.mainPresence)
+    Log.debug('MAIN PRESENCE BACK', account?.data?.mainPresence)
     const auth = store.store.auth
     if (account) {
       account!.nethlinkBounds = nethlinkBounds

src/main/classes/controllers/PhoneIslandController.ts

@@ -4,8 +4,6 @@ import { Log } from '@shared/utils/logger'
 import { AccountController } from './AccountController'
 import { debouncer } from '@shared/utils/utils'
 import { once } from '@/lib/ipcEvents'
-import { useNethVoiceAPI } from '@shared/useNethVoiceAPI'
-import { store } from '@/lib/mainStore'
 import { screen } from 'electron'
 import { Extension, Size } from '@shared/types'
 
@@ -23,8 +21,8 @@ export class PhoneIslandController {
       const { w, h } = size
       const window = this.window.getWindow()
       if (window) {
-        let b = window.getBounds()
-        if (b.height !== h || b.width !== w) {
+        const bounds = window.getBounds()
+        if (bounds.height !== h || bounds.width !== w) {
           window.setBounds({ width: w, height: h })
           PhoneIslandWindow.currentSize = { width: w, height: h }
         }
@@ -101,8 +99,8 @@ export class PhoneIslandController {
     return new Promise<void>((resolve, reject) => {
       try {
         this.window.emit(IPC_EVENTS.LOGOUT)
-        once(IPC_EVENTS.LOGOUT_COMPLETED, () => {
-          this.window.quit(true)
+        once(IPC_EVENTS.LOGOUT_COMPLETED, async () => {
+          await this.window.quit(true)
           resolve()
         })
       } catch (e) {
@@ -113,7 +111,11 @@ export class PhoneIslandController {
   }
 
   call(number: string) {
-    this.window.emit(IPC_EVENTS.START_CALL, number)
+    try {
+      this.window.emit(IPC_EVENTS.START_CALL, number)
+    } catch (e) {
+      Log.error(`Unable to call ${number}`)
+    }
   }
 
   callTransfer(to: string) {

src/main/classes/windows/BaseWindow.ts

@@ -113,7 +113,7 @@ export class BaseWindow {
 
     window.once('ready-to-show', onReady)
     isDev() && window.webContents.ipc.on(IPC_EVENTS.OPEN_DEV_TOOLS, onOpenDevTools)
-
+    !isDev() && window.removeMenu()
     this._window = window
   }
 }

src/main/lib/ipcEvents.ts

@@ -1,7 +1,7 @@
 import { AccountController, DevToolsController } from '@/classes/controllers'
 import { LoginController } from '@/classes/controllers/LoginController'
 import { PhoneIslandController } from '@/classes/controllers/PhoneIslandController'
-import { IPC_EVENTS, PHONE_ISLAND_EVENTS } from '@shared/constants'
+import { IPC_EVENTS } from '@shared/constants'
 import { Account, OnDraggingWindow, PAGES } from '@shared/types'
 import { BrowserWindow, app, ipcMain, screen, shell } from 'electron'
 import { join } from 'path'
@@ -13,7 +13,7 @@ import { debouncer, getAccountUID, getPageFromQuery } from '@shared/utils/utils'
 import { NetworkController } from '@/classes/controllers/NetworkController'
 import { useLogin } from '@shared/useLogin'
 import { PhoneIslandWindow } from '@/classes/windows'
-import http from 'http'
+import { ClientRequest, get } from 'http'
 
 function onSyncEmitter<T>(
   channel: IPC_EVENTS,
@@ -48,31 +48,40 @@ export function registerIpcEvents() {
   let draggingWindows: OnDraggingWindow = {}
 
   onSyncEmitter(IPC_EVENTS.GET_LOCALE, async () => {
-    return app.getSystemLocale()
+    return app.getLocale()
   })
 
   ipcMain.on(IPC_EVENTS.EMIT_START_CALL, async (_event, phoneNumber) => {
     PhoneIslandController.instance.call(phoneNumber)
   })
 
   ipcMain.on(IPC_EVENTS.START_CALL_BY_URL, async (_event, url) => {
-    function triggerError(e, request: http.ClientRequest | undefined = undefined) {
+    function triggerError(e, request: ClientRequest | undefined = undefined) {
       Log.error(e)
-      PhoneIslandController.instance.window.emit(IPC_EVENTS.END_CALL)
-      NethLinkController.instance.window.emit(IPC_EVENTS.RESPONSE_START_CALL_BY_URL, false)
-      request && request.destroy()
+      try {
+        PhoneIslandController.instance.window.emit(IPC_EVENTS.END_CALL)
+        NethLinkController.instance.window.emit(IPC_EVENTS.RESPONSE_START_CALL_BY_URL, false)
+      } catch (e) {
+        Log.error(e)
+      } finally {
+        request && request.destroy()
+      }
     }
     try {
-      const request = http.get(url, {
-        timeout: 3000
-      }, (res) => {
-        if (res.statusCode !== 200) {
-          triggerError(new Error('status error'), request)
+      const request = get(
+        url,
+        {
+          timeout: 3000
+        },
+        (res) => {
+          if (res.statusCode !== 200) {
+            triggerError(new Error('status error'), request)
+          }
+          NethLinkController.instance.window.emit(IPC_EVENTS.RESPONSE_START_CALL_BY_URL, true)
+          PhoneIslandController.instance.window.show()
+          Log.debug('START_CALL_BY_URL', url, res.statusCode)
         }
-        NethLinkController.instance.window.emit(IPC_EVENTS.RESPONSE_START_CALL_BY_URL, true)
-        PhoneIslandController.instance.window.show()
-        Log.info('START_CALL_BY_URL', url, res.statusCode)
-      })
+      )
 
       request.on('error', (e) => {
         triggerError(e, request)
@@ -86,8 +95,13 @@ export function registerIpcEvents() {
     const windows = BrowserWindow.getAllWindows();
     store.updateStore(newState, `${page}[${selector}]`)
     windows.forEach(win => {
-      if (page !== win.webContents.getTitle()) {
-        win.webContents.send(IPC_EVENTS.SHARED_STATE_UPDATED, newState, page);
+      const targetPage = win.webContents.getTitle()
+      try {
+        if (page !== targetPage) {
+          win.webContents.send(IPC_EVENTS.SHARED_STATE_UPDATED, newState, page);
+        }
+      } catch (e) {
+        Log.error(`Data origin: ${page}, target: ${targetPage}`, e)
       }
     });
   });
@@ -173,7 +187,7 @@ export function registerIpcEvents() {
 
   ipcMain.on(IPC_EVENTS.UPDATE_CONNECTION_STATE, (_, isOnline) => {
     if (store.store) {
-      Log.info('INFO update connection state:', isOnline)
+      Log.info('Update connection state:', isOnline)
       store.set('connection', isOnline)
       if (!store.store.account) {
         store.saveToDisk()
@@ -231,10 +245,16 @@ export function registerIpcEvents() {
 
   ipcMain.on(IPC_EVENTS.CHANGE_THEME, (_, theme) => {
     AccountController.instance.updateTheme(theme)
-    //PhoneIslandController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
-    //LoginController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
-    DevToolsController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
-    NethLinkController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
+    try {
+      NethLinkController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
+    } catch (e) {
+      Log.error(e)
+    }
+    try {
+      DevToolsController.instance?.window?.emit(IPC_EVENTS.ON_CHANGE_THEME, theme)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.GET_NETHVOICE_CONFIG, async (e, account) => {
@@ -246,23 +266,43 @@ export function registerIpcEvents() {
   })
 
   ipcMain.on(IPC_EVENTS.EMIT_QUEUE_UPDATE, (_, queue) => {
-    NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_QUEUE_UPDATE, queue)
+    try {
+      NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_QUEUE_UPDATE, queue)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.EMIT_CALL_END, (_) => {
-    NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_CALL_END)
+    try {
+      NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_CALL_END)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.EMIT_MAIN_PRESENCE_UPDATE, (_, mainPresence) => {
-    NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_MAIN_PRESENCE_UPDATE, mainPresence)
+    try {
+      NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_MAIN_PRESENCE_UPDATE, mainPresence)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.EMIT_PARKING_UPDATE, (_) => {
-    NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_PARKING_UPDATE)
+    try {
+      NethLinkController.instance.window.emit(IPC_EVENTS.EMIT_PARKING_UPDATE)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.UPDATE_ACCOUNT, (_) => {
-    NethLinkController.instance.window.emit(IPC_EVENTS.UPDATE_ACCOUNT)
+    try {
+      NethLinkController.instance.window.emit(IPC_EVENTS.UPDATE_ACCOUNT)
+    } catch (e) {
+      Log.error(e)
+    }
   })
 
   ipcMain.on(IPC_EVENTS.RECONNECT_SOCKET, async () => {

src/main/lib/mainStore.ts

@@ -59,7 +59,7 @@ class Store<T> {
 
   updateStore(newState: T, from: string) {
     const diff = difference(Object.values(newState as any || {}), Object.values(this.store as any || {}))
-    Log.info('STORE update shared store from', from, Object.keys(newState as any || {}))
+    Log.debug('STORE update shared store from', from, Object.keys(newState as any || {}))
     if (diff.length > 0 || this.store === undefined) {
       this.store = Object.assign({}, newState)
     }