优化：更新接口对接类

Author: modstart

electron/mapi/app/index.ts

@@ -130,17 +130,18 @@ const spawnShell = async (command: string | string[], option: {
  */
 const availablePort = async (start: number): Promise<number> => {
     for (let i = start; i < 65535; i++) {
-        const available = await isPortAvailable('0.0.0.0', i)
-        // console.log('isPortAvailable', i, available)
-        if (available) {
+        const available = await isPortAvailable(i, '0.0.0.0')
+        const availableLocal = await isPortAvailable(i, '127.0.0.1')
+        // console.log('isPortAvailable', i, available, availableLocal)
+        if (available && availableLocal) {
             return i
         }
     }
     throw new Error('no available port')
 }
 
-const isPortAvailable = async (host: string, port: number): Promise<boolean> => {
 
+const isPortAvailable = async (port: number, host?: string): Promise<boolean> => {
     return new Promise((resolve) => {
         const server = net.createServer()
         server.listen(port, host)
@@ -164,6 +165,8 @@ const fixExecutable = async (executable: string) => {
 export const Apps = {
     shell,
     spawnShell,
+    availablePort,
+    isPortAvailable,
 }
 
 export default {

electron/mapi/event/main.ts

@@ -2,12 +2,13 @@ import {AppRuntime} from "../env";
 import {ipcMain} from "electron";
 import {StrUtil} from "../../lib/util";
 
+
 const init = () => {
 
 }
 
 type NameType = 'main' | string
-type EventType = 'APP_READY' | 'CALL_THIRD_PARTY' | 'CALL_PAGE'
+type EventType = 'APP_READY' | 'CALL_THIRD_PARTY' | 'CALL_PAGE' | 'CHANNEL'
 
 const send = (name: NameType, type: EventType, data: any = {}, id?: string): boolean => {
     id = id || StrUtil.randomString(32)
@@ -16,6 +17,7 @@ const send = (name: NameType, type: EventType, data: any = {}, id?: string): boo
         if (!AppRuntime.mainWindow) {
             return false
         }
+        // console.log('send', payload)
         AppRuntime.mainWindow?.webContents.send('MAIN_PROCESS_MESSAGE', payload)
     } else {
         if (!AppRuntime.windows[name]) {
@@ -76,11 +78,49 @@ ipcMain.handle('event:callPage', async (_, name: string, type: string, data: any
     })
 })
 
+const sendChannel = (channel: string, data: any) => {
+    send('main', 'CHANNEL', {channel, data})
+}
+
+let onChannelIsListen = false
+let channelOnCallback = {}
+
+const onChannel = (channel: string, callback: (data: any) => void) => {
+    if (!channelOnCallback[channel]) {
+        channelOnCallback[channel] = []
+    }
+    channelOnCallback[channel].push(callback)
+    if (!onChannelIsListen) {
+        onChannelIsListen = true
+        ipcMain.handle('event:channelSend', (event, channel_, data) => {
+            if (channelOnCallback[channel_]) {
+                channelOnCallback[channel_].forEach((callback: (data: any) => void) => {
+                    callback(data)
+                })
+            }
+        })
+    }
+}
+
+const offChannel = (channel: string, callback: (data: any) => void) => {
+    if (channelOnCallback[channel]) {
+        channelOnCallback[channel] = channelOnCallback[channel].filter((item: (data: any) => void) => {
+            return item !== callback
+        })
+    }
+    if (channelOnCallback[channel].length === 0) {
+        delete channelOnCallback[channel]
+    }
+}
+
 export default {
     init,
     send
 }
 
 export const Events = {
-    send
+    send,
+    sendChannel,
+    onChannel,
+    offChannel,
 }

electron/mapi/event/render.ts

@@ -5,7 +5,7 @@ const init = () => {
 }
 
 const send = (name: string, type: string, data: any = {}) => {
-    ipcRenderer.invoke('event:send', name, type, data).then()
+    return ipcRenderer.invoke('event:send', name, type, data).then()
 }
 
 const callThirdParty = async (name: string, type: string, data: any, option: any) => {
@@ -16,9 +16,28 @@ const callPage = async (name: string, type: string, data: any, option: any) => {
     return ipcRenderer.invoke('event:callPage', name, type, data, option)
 }
 
+
+const channelCreate = async (callback: (data: any) => void) => {
+    const channel = Math.random().toString(36).substring(2)
+    window['__channel'] = window['__channel'] || {}
+    window['__channel'][channel] = callback
+    return channel
+}
+
+const channelDestroy = async (channel: string) => {
+    delete window['__channel'][channel]
+}
+
+const channelSend = async (channel: string, data: any) => {
+    return ipcRenderer.invoke('event:channelSend', channel, data)
+}
+
 export default {
     init,
     send,
     callThirdParty,
-    callPage
+    callPage,
+    channelCreate,
+    channelDestroy,
+    channelSend,
 }

electron/mapi/main.ts

@@ -11,6 +11,8 @@ import page from "./page/main";
 import user from "./user/main";
 import misc from "./misc/main";
 
+import server from "./server/main";
+
 const $mapi = {
     app,
     log,
@@ -23,7 +25,8 @@ const $mapi = {
     keys,
     page,
     user,
-    misc
+    misc,
+    server
 }
 
 export const MAPI = {

electron/mapi/misc/main.ts

@@ -9,4 +9,6 @@ ipcMain.handle('misc:unzip', async (_, zipPath: string, dest: string) => {
     return await index.unzip(zipPath, dest)
 })
 
-export default {}
+export default {
+    ...index,
+}

electron/mapi/render.ts

@@ -17,6 +17,7 @@ import user from "./user/render";
 import misc from "./misc/render";
 
 import ffmpeg from "./ffmpeg/render";
+import server from "./server/render";
 
 export const MAPI = {
     init(env: typeof AppEnv = null) {
@@ -39,6 +40,7 @@ export const MAPI = {
                 misc,
 
                 ffmpeg,
+                server,
             })
             db.init()
             event.init()

electron/mapi/server/api.ts

@@ -0,0 +1,108 @@
+import {net} from 'electron'
+import {Client, handle_file} from "@gradio/client";
+import {platformArch, platformName} from "../../lib/env";
+import {Events} from "../event/main";
+import {Apps} from "../app";
+import {Files} from "../file/main";
+import fs from 'node:fs'
+
+const request = async (url, data?: {}, option?: {}) => {
+    option = Object.assign({
+        method: 'GET',
+        timeout: 60 * 1000,
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        responseType: 'json' as 'json'
+    })
+    if (option['method'] === 'GET') {
+        url += '?'
+        for (let key in data) {
+            url += `${key}=${data[key]}&`
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const req = net.request({
+            url,
+            method: option['method'],
+            headers: option['headers'],
+        })
+        req.on('response', (response) => {
+            let body = ''
+            response.on('data', (chunk) => {
+                body += chunk.toString()
+            })
+            response.on('end', () => {
+                if ('json' === option['responseType']) {
+                    try {
+                        resolve(JSON.parse(body))
+                    } catch (e) {
+                        resolve({code: -1, msg: `ResponseError: ${body}`})
+                    }
+                } else {
+                    resolve(body)
+                }
+            })
+        })
+        req.on('error', (err) => {
+            reject(err)
+        })
+        req.end()
+    })
+}
+
+const requestPost = async (url, data?: {}, option?: {}) => {
+    option = Object.assign({
+        method: 'POST',
+    })
+    return request(url, data, option)
+}
+
+const requestGet = async (url, data?: {}, option?: {}) => {
+    option = Object.assign({
+        method: 'GET',
+    })
+    return request(url, data, option)
+}
+
+const requestPostSuccess = async (url, data?: {}, option?: {}) => {
+    const res = await requestPost(url, data, option)
+    if (res['code'] === 0) {
+        return res
+    }
+    throw new Error(res['msg'])
+}
+
+const requestUrlFileToLocal = async (url, path) => {
+    return new Promise((resolve, reject) => {
+        const req = net.request(url)
+        req.on('response', (response) => {
+            const file = fs.createWriteStream(path)
+            // @ts-ignore
+            response.pipe(file)
+            file.on('finish', () => {
+                file.close()
+                resolve('x')
+            })
+        })
+        req.on('error', (err) => {
+            reject(err)
+        })
+        req.end()
+    })
+}
+
+export default {
+    GradioClient: Client,
+    GradioHandleFile: handle_file,
+    event: Events,
+    file: Files,
+    app: Apps,
+    request,
+    requestPost,
+    requestGet,
+    requestPostSuccess,
+    requestUrlFileToLocal,
+    platformName: platformName(),
+    platformArch: platformArch(),
+}

electron/mapi/server/main.ts

@@ -0,0 +1,61 @@
+import ServerApi from './api'
+import {ipcMain} from "electron";
+import file from "../file";
+
+const serverModule = {}
+
+const init = () => {
+
+}
+
+const getModule = async (serverInfo: ServerInfo) => {
+    // console.log('getModule', serverInfo)
+    if (!serverModule[serverInfo.localPath]) {
+        try {
+            const serverPath = `${serverInfo.localPath}/server.js`
+            const module = await import(`file://${serverPath}`)
+            // console.log('module', module)
+            await module.default.init(ServerApi)
+            serverModule[serverInfo.localPath] = module.default
+        } catch (e) {
+            console.error('getModule.error', e)
+            throw new Error(e)
+        }
+    }
+    return serverModule[serverInfo.localPath]
+}
+
+ipcMain.handle('server:start', async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo)
+    return await module.start(serverInfo)
+})
+
+ipcMain.handle('server:ping', async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo)
+    return await module.ping()
+})
+
+ipcMain.handle('server:stop', async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo)
+    return await module.stop(serverInfo)
+})
+
+ipcMain.handle('server:config', async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo)
+    return await module.config()
+})
+
+ipcMain.handle('server:callFunction', async (event, serverInfo: ServerInfo, method: string, data: any) => {
+    // console.log('getModule.before', serverInfo, method)
+    const module = await getModule(serverInfo)
+    // console.log('getModule.end', serverInfo, method, module)
+    const func = module[method]
+    if (!func) {
+        throw new Error(`MethodNotFound : ${method}`)
+    }
+    return await func.bind(module)(serverInfo, data)
+})
+
+export default {
+    init
+}

electron/mapi/server/render.ts

@@ -0,0 +1,29 @@
+import {ipcRenderer} from 'electron'
+
+const start = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke('server:start', serverInfo)
+}
+
+const ping = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke('server:ping', serverInfo)
+}
+
+const stop = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke('server:stop', serverInfo)
+}
+
+const config = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke('server:config', serverInfo)
+}
+
+const callFunction = async (serverInfo: ServerInfo, method: string, data: any) => {
+    return ipcRenderer.invoke('server:callFunction', serverInfo, method, data)
+}
+
+export default {
+    start,
+    ping,
+    stop,
+    config,
+    callFunction,
+}

electron/mapi/server/type.d.ts

@@ -0,0 +1,9 @@
+interface ServerInfo {
+    localPath: string,
+    name: string,
+    version: string,
+    setting: {
+        [key: string]: any,
+    },
+    logFile: string,
+}