mirror of
https://gitee.com/energye/energy.git
synced 2024-12-11 03:07:29 +08:00
196 lines
6.6 KiB
Go
196 lines
6.6 KiB
Go
//----------------------------------------
|
|
//
|
|
// Copyright © yanghy. All Rights Reserved.
|
|
//
|
|
// Licensed under Apache License Version 2.0, January 2004
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
//----------------------------------------
|
|
|
|
// IPC
|
|
|
|
package cef
|
|
|
|
import (
|
|
"github.com/energye/energy/v2/cef/internal/ipc"
|
|
"github.com/energye/energy/v2/cef/process"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// ipc bind event name
|
|
const (
|
|
internalIPC = "ipc" // JavaScript -> ipc 事件驱动, 根对象名
|
|
internalIPCEmit = "emit" // JavaScript -> ipc.emit 在 JavaScript 触发 GO 监听事件函数名, 异步
|
|
internalIPCEmitWait = "emitWait" // JavaScript -> ipc.emitWait 在 JavaScript 触发 GO 监听事件函数名, 等待超时返回结果
|
|
internalIPCOn = "on" // JavaScript -> ipc.on 在 JavaScript 监听事件, 提供给 GO 调用
|
|
internalIPCDRAG = "drag" // JavaScript -> ipc.on drag
|
|
)
|
|
|
|
// ipc message name
|
|
const (
|
|
internalIPCJSExecuteGoEvent = "JSEmitGo" // JS 触发 GO事件异步
|
|
internalIPCJSExecuteGoEventReplay = "JSEmitGoReplay" // JS 触发 GO事件异步 - 返回结果
|
|
internalIPCJSExecuteGoWaitEvent = "JSEmitWaitGo" // JS 触发 GO事件同步
|
|
internalIPCJSExecuteGoWaitEventReplay = "JSEmitWaitGoReplay" // JS 触发 GO事件同步 - 返回结果
|
|
internalIPCGoExecuteJSEvent = "GoEmitJS" // GO 触发 JS事件
|
|
internalIPCGoExecuteJSEventReplay = "GoEmitJSReplay" // GO 触发 JS事件 - 返回结果
|
|
)
|
|
|
|
// js execute go 返回类型
|
|
type result_type int8
|
|
|
|
const (
|
|
rt_function result_type = iota //回调函数
|
|
rt_variable //变量接收
|
|
)
|
|
|
|
var (
|
|
internalObjectRootName = "energy" // GO 和 V8Value 绑定根对象名
|
|
ipcRender *ipcRenderProcess // 渲染进程 IPC
|
|
ipcBrowser *ipcBrowserProcess // 主进程 IPC
|
|
)
|
|
|
|
// ipcEmitHandler ipc.emit 处理器
|
|
type ipcEmitHandler struct {
|
|
handler *ICefV8Handler // ipc.emit handler
|
|
handlerSync *ICefV8Handler // ipc.emitSync handler
|
|
callbackList map[int32]*ipcCallback // ipc.emit callbackList *list.List
|
|
callbackMessageId int32 // ipc.emit messageId
|
|
callbackLock sync.Mutex // ipc.emit lock
|
|
}
|
|
|
|
// ipcOnHandler ipc.on 处理器
|
|
type ipcOnHandler struct {
|
|
handler *ICefV8Handler // ipc.on handler
|
|
callbackList map[string]*ipcCallback // ipc.on callbackList
|
|
callbackLock sync.Mutex // ipc.emit lock
|
|
}
|
|
|
|
// ipcCallback ipc.emit 回调结果
|
|
type ipcCallback struct {
|
|
isSync bool //同否同步 true:同步 false:异步, 默认false
|
|
resultType result_type //返回值类型 0:function 1:variable 默认:0
|
|
variable *ICefV8Value //回调函数, 根据 resultType
|
|
function *ICefV8Value //回调函数, 根据 resultType
|
|
name *ICefV8Value //事件名称
|
|
}
|
|
|
|
// isIPCInternalKey IPC 内部定义使用 key 不允许使用
|
|
func isIPCInternalKey(key string) bool {
|
|
return key == internalIPC || key == internalIPCEmit || key == internalIPCOn || key == internalIPCDRAG || key == internalIPCEmitWait ||
|
|
key == internalIPCJSExecuteGoEvent || key == internalIPCJSExecuteGoEventReplay ||
|
|
key == internalIPCGoExecuteJSEvent || key == internalIPCGoExecuteJSEventReplay ||
|
|
key == internalIPCJSExecuteGoWaitEvent || key == internalIPCJSExecuteGoWaitEventReplay
|
|
|
|
}
|
|
|
|
// ipcInit 初始化
|
|
func ipcInit() {
|
|
isSingleProcess := application.SingleProcess()
|
|
if isSingleProcess {
|
|
ipcBrowser = &ipcBrowserProcess{}
|
|
ipcRender = &ipcRenderProcess{
|
|
waitChan: &ipc.WaitChan{Pending: new(sync.Map)},
|
|
emitHandler: &ipcEmitHandler{callbackList: make(map[int32]*ipcCallback)},
|
|
onHandler: &ipcOnHandler{callbackList: make(map[string]*ipcCallback)},
|
|
}
|
|
ipc.CreateBrowserIPC() // Go IPC browser
|
|
ipc.CreateRenderIPC(0, time.Now().UnixNano()/1e6) // Go IPC render
|
|
} else {
|
|
if process.Args.IsMain() {
|
|
ipcBrowser = &ipcBrowserProcess{}
|
|
ipc.CreateBrowserIPC() // Go IPC browser
|
|
} else if process.Args.IsRender() {
|
|
ipcRender = &ipcRenderProcess{
|
|
waitChan: &ipc.WaitChan{Pending: new(sync.Map)},
|
|
emitHandler: &ipcEmitHandler{callbackList: make(map[int32]*ipcCallback)},
|
|
onHandler: &ipcOnHandler{callbackList: make(map[string]*ipcCallback)},
|
|
}
|
|
ipc.CreateRenderIPC(0, time.Now().UnixNano()/1e6) // Go IPC render
|
|
}
|
|
}
|
|
}
|
|
|
|
// addCallback
|
|
func (m *ipcEmitHandler) addCallback(callback *ipcCallback) int32 {
|
|
//return uintptr(unsafe.Pointer(m.callbackList.PushBack(callback)))
|
|
m.callbackLock.Lock()
|
|
defer m.callbackLock.Unlock()
|
|
m.callbackList[m.nextMessageId()] = callback
|
|
return m.callbackMessageId
|
|
}
|
|
|
|
// nextMessageId 获取下一个消息ID
|
|
func (m *ipcEmitHandler) nextMessageId() int32 {
|
|
m.callbackMessageId++
|
|
if m.callbackMessageId == -1 {
|
|
m.callbackMessageId = 1
|
|
}
|
|
return m.callbackMessageId
|
|
}
|
|
|
|
// getCallback 返回回调函数
|
|
func (m *ipcEmitHandler) getCallback(messageId int32) *ipcCallback {
|
|
//return (*list.Element)(unsafe.Pointer(ptr)).Value.(*ipcCallback)
|
|
m.callbackLock.Lock()
|
|
defer m.callbackLock.Unlock()
|
|
if callback, ok := m.callbackList[messageId]; ok {
|
|
delete(m.callbackList, messageId)
|
|
return callback
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// clear 清空所有回调函数
|
|
func (m *ipcEmitHandler) clear() {
|
|
for _, v := range m.callbackList {
|
|
v.function.SetCanNotFree(false)
|
|
v.function.Free()
|
|
v.name.Free()
|
|
}
|
|
m.callbackMessageId = 0
|
|
m.callbackList = make(map[int32]*ipcCallback)
|
|
}
|
|
|
|
// addCallback 根据事件名添加回调函数
|
|
func (m *ipcOnHandler) addCallback(eventName string, callback *ipcCallback) {
|
|
//return uintptr(unsafe.Pointer(m.callbackList.PushBack(callback)))
|
|
m.callbackLock.Lock()
|
|
defer m.callbackLock.Unlock()
|
|
if callbk, ok := m.callbackList[eventName]; ok {
|
|
//如果重复将之前释放掉
|
|
callbk.function.SetCanNotFree(false)
|
|
callbk.function.Free()
|
|
callbk.name.Free()
|
|
}
|
|
m.callbackList[eventName] = callback
|
|
}
|
|
|
|
// removeCallback 根据事件名移除回调函数
|
|
func (m *ipcOnHandler) removeCallback(eventName string) {
|
|
//m.callbackList.Remove((*list.Element)(unsafe.Pointer(ptr)))
|
|
m.callbackLock.Lock()
|
|
defer m.callbackLock.Unlock()
|
|
delete(m.callbackList, eventName)
|
|
}
|
|
|
|
// getCallback 根据事件名返回回调函数
|
|
func (m *ipcOnHandler) getCallback(eventName string) *ipcCallback {
|
|
//return (*list.Element)(unsafe.Pointer(ptr)).Value.(*ipcCallback)
|
|
m.callbackLock.Lock()
|
|
defer m.callbackLock.Unlock()
|
|
return m.callbackList[eventName]
|
|
}
|
|
|
|
// clear 清空所有回调函数
|
|
func (m *ipcOnHandler) clear() {
|
|
for _, v := range m.callbackList {
|
|
v.function.SetCanNotFree(false)
|
|
v.function.Free()
|
|
v.name.Free()
|
|
}
|
|
m.callbackList = make(map[string]*ipcCallback)
|
|
}
|