feat: 基础交互api完善

src/apis/baseApi.ts

@@ -0,0 +1,358 @@
+/**
+ * 返回基础api的请求函数, 用于封装请求. 用于同时支持浏览器和electron环境
+ */
+import {ApiType, ErrorCode, NotifyData, RequestData, ResponseData} from "@/types/apiTypes.ts";
+import {randomId} from "@/util/random.ts";
+import {ipcRenderer} from "electron";
+import {actionMap} from "@/tools/IpcCmd.ts";
+
+interface CallItem {
+    callId: string;
+    action: string;
+    resolve: (value: ResponseData) => void;
+    reject: (reason: any) => void;
+    endTime: number;
+    // 是否在初始化前尝试发送
+    isInit: boolean;
+}
+interface Calls {
+    [key: string]: CallItem;
+}
+
+interface NotifyItem {
+    action: string;
+    handlers: {
+        [key: string]:{
+            callback: (params: any) => void;
+            isOnce: boolean;
+        }
+    }
+}
+interface NotifyMap {
+    [key: string]: NotifyItem;
+}
+
+// 定义send函数的数据类型
+export type SendFunction = (channel: string,     ...args: any[])=> void
+
+export type ListenerFunction = (channel: string, listener: (event: any, ...args: any[]) => void) => void
+
+
+
+class ApiController {
+    sign = ''
+    calls: Calls = {}
+    notifyMap: NotifyMap = {}
+    // 最近的一个过期时间
+    lastCheckTime = 0
+    // 最近的过期检测id
+    lastCheckId: string = ""
+    checkTimer: NodeJS.Timeout | null = null
+    // 下一次检测的间隔时间
+    checkInterval = 100
+    isInit: boolean = false
+    // init 前尝试发送的数据
+    sendTasks: RequestData[] = []
+    // init 前尝试取消的发送
+    cancelTasks: string[] = []
+    sendCallback: SendFunction | null = null;
+    sendKey: string = ""
+    listenerKey: string = ""
+    listenerCallback: ListenerFunction | null = null;
+    logFn: (...args: any[]) => void = console.log
+    constructor() {
+    }
+    init(sign: string, sendCallback: SendFunction, listenerCallback: ListenerFunction, sendKey: string, listerKey: string){
+        this.isInit = true
+        this.sign = sign
+        this.sendCallback = sendCallback
+        this.listenerCallback = listenerCallback
+        this.sendKey = sendKey
+        this.listenerKey = listerKey
+        this.listenerCallback(listerKey, this.apiControllerHandler)
+        this.sendTasks.forEach(requestData => {
+            sendCallback(sendKey, requestData)
+            this.refreshTimeout(requestData.callId, requestData.timeout)
+        })
+        this.cancelTasks.forEach(callId => {
+            this.cancelQuery(callId)
+        })
+    }
+    setLogFn(logFn: (...args: any[]) => void){
+        this.logFn = logFn
+    }
+    /**
+     * 构建新的callId
+     */
+    private buildCallId( deep: number = 0) : string {
+        let callId = randomId()
+        if(!this.calls[callId]){
+            return callId
+        }
+        if(deep > 10){
+            return `${callId}${deep}${randomId()}`
+        }
+        return this.buildCallId(deep++)
+    }
+    /**
+     * 构建新的notifyId
+     */
+    private buildNotifyId(action: string, deep: number = 0) : string {
+        let notifyId = randomId()
+        if(!this.notifyMap[action] || !this.notifyMap[action].handlers[notifyId]){
+            return notifyId
+        }
+        if(deep > 10){
+            return `${notifyId}${deep}${randomId()}`
+        }
+        return this.buildNotifyId(action)
+    }
+    private apiControllerHandler(_:any, data: ResponseData | NotifyData)
+    {
+        switch(data.type){
+            case ApiType.res:
+                if(this.calls[data.callId]){
+                    this.callResponseHandle(this.calls[data.callId], data)
+                }
+                break;
+            case ApiType.notify:
+                if(this.notifyMap[data.action])
+                {
+                    this.notifyHandle(this.notifyMap[data.action], data)
+                }
+                break;
+        }
+    }
+    private callResponseHandle(call: CallItem, responseData: ResponseData){
+        if( this.lastCheckId === call.callId){
+            // 取消检测当前函数的定时器, 防止多次触发
+            if(this.checkTimer){
+                clearTimeout(this.checkTimer)
+            }
+            this.checkTimer = null
+            this.lastCheckId = "";
+            this.lastCheckTime = 0;
+
+        }
+        // 执行回调
+        call.resolve(responseData)
+        // 从队列中删除
+        delete this.calls[call.callId]
+        this.findNextTimeoutCall()
+    }
+    private notifyHandle(notify: NotifyItem, data: NotifyData) {
+        for (const notifyHandleId in notify.handlers) {
+            let notifyHandle = notify.handlers[notifyHandleId]
+            notifyHandle.callback(data)
+            if(notifyHandle.isOnce){
+                delete notify.handlers[notifyHandleId]
+            }
+        }
+    }
+
+
+    private startTimeoutCheck(callId: string){
+        // 获取当前的时间戳
+        let nowTimeStamp = Date.now()
+        // 获取对应call的超时时间
+        let callItem = this.calls[callId]
+        if (!callItem)
+        {
+            return this.logFn(`[E] startTimeoutCheck: ${callId} not found`)
+        }
+
+        let timeWait = callItem.endTime - nowTimeStamp - this.checkInterval
+        // 在已经有一个超时检查的情况下, 判断新的超时时间是否小于当前正在执行的超时时间. 用于将计时器更新为最新的
+        if(this.lastCheckId && callId !== this.lastCheckId){
+            if(callItem.endTime < this.lastCheckTime){
+                this.lastCheckTime = callItem.endTime
+                this.lastCheckId = callId
+                // 取消计时器
+                if(this.checkTimer)
+                {
+                    clearTimeout(this.checkTimer)
+                    this.checkTimer = null
+                }
+                // 获取
+                this.checkTimer = setTimeout(() => {
+                    this.checkTimeout()
+                }, timeWait)
+            }
+            return;
+        }
+        this.lastCheckTime = callItem.endTime
+        this.lastCheckId = callId
+        if(timeWait > 0){
+            
+            this.checkTimer = setTimeout(() => {
+                this.checkTimeout()
+            }, timeWait)
+        }
+        if(timeWait <= 0){
+            // 立即执行
+            this.checkTimeout()
+        }
+    }
+    // 超时检查
+    private checkTimeout() {
+        let callItem = this.calls[this.lastCheckId]
+        if(!callItem || callItem.endTime != -1){
+            // 尝试获取calls中获取到期时间最小的一个请求
+            this.logFn(`[W] checkTimeout: ${this.lastCheckId} not supported check timeoutDate: ${callItem?.endTime}`)
+            return this.findNextTimeoutCall()
+        }
+        let nowTimeStamp = Date.now()
+        if (callItem.endTime > nowTimeStamp){
+            this.callTimeoutHandle(callItem)
+        }
+        // 暂未超时,
+        this.startTimeoutCheck(this.lastCheckId)
+    }
+    private callTimeoutHandle(callItem: CallItem)
+    {
+        // 移除超时检查
+        this.lastCheckTime = 0;
+        this.lastCheckId = "";
+        this.callResponseHandle(callItem, {
+            type: ApiType.res,
+            action: callItem.action,
+            callId: callItem.callId,
+            code: ErrorCode.timeout,
+            msg: '等待api响应数据超时!',
+            data: null,
+        })
+        // 寻找下一个超时检查项
+        this.findNextTimeoutCall()
+    }
+    private findNextTimeoutCall()
+    {
+        // 遍历请求,
+        for(let callId in this.calls){
+            let callItem = this.calls[callId]
+            if (callItem.endTime === -1){
+                continue;
+            }
+            this.lastCheckTime = callItem.endTime;
+            this.lastCheckId = callId;
+            if(callItem.endTime < this.lastCheckTime){
+                this.lastCheckTime = callItem.endTime
+                this.lastCheckId = callId
+            }
+        }
+        if(this.lastCheckId !== ""){
+            this.startTimeoutCheck(this.lastCheckId)
+        }else{
+            // 没有找到超时检查项, 则取消计时器
+        }
+    }
+    // 刷新超时时间
+    refreshTimeout(callId: string, timeout: number) {
+        let callItem = this.calls[callId]
+        if(!callItem){
+            return this.logFn(`[E] refreshTimeout: ${callId} not found`)
+        }
+        callItem.endTime = Date.now() + timeout
+        this.startTimeoutCheck(callId)
+    }
+
+    /**
+     * 修改当前总api的签名
+     * @param sign
+     */
+    changeSign(sign: string) {
+        this.sign = sign
+    }
+
+    /**
+     * 调用ipc 获取数据
+     * @param action
+     * @param params
+     * @param timeout
+     */
+    sendQuery(action: string, params: any, timeout: number = 5000) {
+        let callId = this.buildCallId()
+        let requestData: RequestData = {
+            type: ApiType.req,
+            action: action,
+            data: params,
+            callId: callId,
+            timeout: timeout,
+        }
+        if(this.isInit){
+            if (this.sendCallback){
+                this.sendCallback(this.sendKey, requestData)
+            }else {
+                this.logFn(`[E] sendQuery: ${action} not init data`)
+            }
+        }else{
+            this.sendTasks.push(requestData)
+        }
+
+        // 获取当前的时间戳
+        let timeStamp = Date.now()
+        // 加上通信超时时间
+        let endTime = timeStamp +  + 200
+        // 如果是-1, 则表示不设置超时时间, 永久等待检测
+        if(timeout === -1){
+            endTime = -1
+        }else{
+            if(this.isInit){
+                this.startTimeoutCheck(callId)
+            }else{
+                this.logFn(`!!!Try calling the send function before initializing`)
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.calls[callId] = {
+                action: action,
+                callId: callId,
+                resolve: resolve,
+                reject: reject,
+                endTime: endTime,
+                isInit: !this.isInit,
+            }
+        })
+    }
+    registerNotify(action: string, isOnce: boolean = false, callback: (params: any) => void): string {
+        if (!this.notifyMap[action]) {
+            // 初始化 notify 对象
+            this.notifyMap[action] = {
+                action: action,
+                handlers: {},
+            }
+        }
+        let callId = this.buildNotifyId(action)
+        this.notifyMap[action].handlers[callId] = {
+            callback: callback,
+            isOnce: isOnce,
+        }
+        return callId
+    }
+    // 取消方法
+    cancelQuery(callId: string) {
+        if(this.calls[callId]){
+
+            this.callResponseHandle(this.calls[callId], {
+                type: ApiType.res,
+                action: this.calls[callId].action,
+                callId: this.calls[callId].callId,
+                code: ErrorCode.cancel,
+                msg: '取消请求',
+                data: null,
+            })
+            delete this.calls[callId]
+        }
+    }
+    destroy() {
+        ipcRenderer.removeListener(actionMap.apiControllerHandler.code, this.apiControllerHandler)
+    }
+}
+
+
+// 使用单例模式创建ApiController
+let api: ApiController | null = null
+if(!api){
+    api = new ApiController()
+}
+export default api as ApiController
+

src/apis/magnetControl.ts

@@ -0,0 +1,3 @@
+function getMagnetList(){
+
+}

src/tools/IpcCmd.ts

@@ -84,6 +84,12 @@ export const actionMap: { [key: string]: IpcAction } = {
         icon: 'query',
         code: 'questionUser',
         resCode: 'userAnswer'
+    },
+    apiControl: {
+        title: 'api调用',
+        icon: 'api',
+        code: 'apiControl',
+        resCode: 'apiControl_replay'
     }
 }
 

src/types/apiTypes.ts

@@ -0,0 +1,71 @@
+export enum ErrorCode {
+    success = 0,
+    // 参数错误
+    params,
+    // 权限错误
+    permission,
+    // 请求超时, 可能是由发送者触发, 也有可能是服务端处理其他任务时超时
+    timeout,
+    // 被取消请求, 一般由发起者触发, 也有可能是由其他客户端将其取消
+    cancel,
+
+
+}
+
+// 请求类型
+export enum ApiType {
+    req = 0xFF,
+    // 请求的响应
+    res = 0xFE,
+    notify = 0xFD,
+}
+
+
+// 请求参数
+export interface RequestData
+{
+    type: ApiType.req;
+    callId: string;
+    // 请求的具体操作
+    action: string;
+    data: any;
+    // 超时时间, 单位毫秒
+    timeout: number;
+}
+
+export interface ResponseData
+{
+    type: ApiType.res;
+    callId: string;
+    // 请求的具体操作
+    action: string;
+    // 错误码
+    code: ErrorCode;
+    // 错误信息
+    msg: string;
+    // 返回的数据
+    data: any;
+}
+
+export interface NotifyData
+{
+    type: ApiType.notify;
+    // 请求的具体操作
+    action: string;
+    // 错误码
+    code: ErrorCode;
+    // 错误信息
+    msg: string;
+    // 返回的数据
+    data: any;
+}
+
+
+export enum magnet_Actions {
+    // 获取列表
+    magnet_list = 'magnet_list',
+    // 批量更改磁力链接
+    magnet_batch_update = 'magnet_batch_update',
+    // 删除磁力链接
+    magnet_delete = 'magnet_delete',
+}

src/util/pageHandle.ts

@@ -1,8 +1,9 @@
 import {App} from "vue";
 
 import {ipcRenderer} from "electron";
-import {IpcAction, windowAction} from "../tools/IpcCmd.ts";
+import {actionMap, IpcAction, windowAction} from "../tools/IpcCmd.ts";
 import {registerWindowData} from "../types/appConfig.ts";
+import baseApi from "@/apis/baseApi.ts";
 
 // 判断是否为 webMode
 
@@ -50,6 +51,13 @@ function tryBindWindow(ipc: Electron.IpcRenderer, type: string): (action: IpcAct
 export function windowInit(app: App, type: string){
     // 先将验证窗口绑定到全局, 接收到 绑定消息后再进行绑定
     app.config.globalProperties.$winHandle = tryBindWindow(ipcRenderer, type)
+    // 初始化api调用函数. 用于统一调用
+    baseApi.init(type,
+        ipcRenderer.send,
+        ipcRenderer.on,
+        actionMap.apiControl.code,
+        actionMap.apiControl.resCode);
+
     ipcRenderer.on(
     windowAction.bindSignId.code,
     (_: Electron.IpcRendererEvent , data: registerWindowData)=>

src/util/random.ts

@@ -1,3 +1,5 @@
 export function randomId() {
     return Math.random().toString(36).substr(4);
 }
+
+

功能文档.md

@@ -1,8 +1,12 @@
 # 功能管理
+
 ## 接口设计
+
 ### 设计准则
+
 #c 设计准则
 为了满足以下需求:
+
 1. 不同协议下的调用效果一致
 2. 准确告知调用结果
 3. 能够查询调用状态
@@ -14,18 +18,24 @@
 同时数据应该包含一个字段用于区分是响应, 还是调用, 还是通知  
 通知字段用于不同端之间进行主动触发
 
-
 #d 结构体设计  
-使用json进行数据传递  
+使用json进行数据传递
 
-| 字段名    | 描述                      |
-|--------|-------------------------|
-| type   | 类型, 用于区分是响应, 还是调用, 还是通知 |
-| action | 执行的什么操作                 |
-| callId | 调用id,用于区分是那一次调用         |
-| params | 参数, 使用接送                |
+| 字段名    | 描述                      | 可选值              |
+|--------|-------------------------|------------------|
+| type   | 类型, 用于区分是响应, 还是调用, 还是通知 | req, res, notify |
+| action | 执行的什么操作                 |                  |
+| callId | 调用id,用于区分是那一次调用         |                  |
+| params | 参数, 使用传递参数              |                  |
+| code   | 返回值                     |                  |
+| msg    | 描述文字                    |                  |
 
 ## 桌面小组件管理功能
+
 ### 桌面编辑
-1. 桌面上拖动,组件
+
+1. 组件更改
+   type: req
+   action: magnet_edit
+   params: 修改的组件信息
 2. 移除组件