键盘监听与协程

package cmd

import (
"live-command-middleware/mylog/wlog"
"live-command-middleware/trigger"
"live-command-middleware/websocket/ws"
"os"
"time"

"github.com/spf13/cobra"
)

// startCmd represents the start command
var startCmd = &cobra.Command{
Use: "start",
Short: "开始服务",
Long: `会开始监听操作`,
Run: func(cmd *cobra.Command, args []string) {
wlog.Info("程序开始")

keyboardControlChan := make(chan string)

err := ws.NewWsClient(keyboardControlChan)
if err != nil {
// 重试连接
reTryNum := 100
for i := 0; i < reTryNum; i++ {
time.Sleep(1 * time.Second)
wlog.Infof("第 %d 次重试连接", i+1)
err = ws.NewWsClient(keyboardControlChan)
if err == nil {
break
}
}
wlog.Errorf("ws连接失败 Error: %v", err)
os.Exit(10002)
}
ws.WsClient.StartHeartBeat()
wlog.Infof("ws连接成功，等待接受信号...")

for {
select {
case cmd := <-keyboardControlChan:
if cmd == "start" {
wlog.Infof("主线程收到启动键盘监听指令")
trigger.StartListenKeyBoard() // 启动键盘监听
} else if cmd == "stop" {
wlog.Infof("主线程收到停止键盘监听指令")
trigger.StopListenKeyBoard() // 停止键盘监听
}
}
}
},
}

func init() {
rootCmd.AddCommand(startCmd)
}


package trigger

import (
"live-command-middleware/chrome"
"live-command-middleware/enum"
"live-command-middleware/gopool"
"live-command-middleware/instruction"
"live-command-middleware/mylog/wlog"
"live-command-middleware/setting"
"strings"
"sync"

hook "github.com/robotn/gohook"
"github.com/vcaesar/keycode"
)

var (
hookChan chan hook.Event
hookRunning bool = false
KeyBoardGlobalLock = sync.Mutex{}
)

func NewInstructionStructByOperate(operate string) instruction.Instruction {
switch operate {
case enum.OperationPreheatProduct:
return &instruction.PreheatProduct{}
case enum.OperationExplainProduct:
return &instruction.ExplainProduct{}
case enum.OperationExplainProductAll:
return &instruction.ExplainProductAll{}
case enum.OperationChangePrice:
return &instruction.ChangePrice{}
case enum.OperateCoupon:
return &instruction.Coupon{}
case enum.OperateRedBag:
return &instruction.RedBag{}
case enum.OperateLuckyBag:
return &instruction.LuckBag{}
case enum.OperationComment:
return &instruction.Comment{}
case enum.OperateWindowOpen:
return &instruction.WindowOpen{}
case enum.OperateCancel:
return &instruction.Cancel{}
case enum.Audio:
return &instruction.Audio{}
default:
return nil
}
}

var ExecMapInstructionStruct = map[string]string{
enum.OperationPreheatProduct: enum.SafeExecIfNotExists,
enum.OperationExplainProduct: enum.SafeExec,
enum.OperationExplainProductAll: enum.SafeExec,
enum.OperationChangePrice: enum.NullExec,
enum.OperateCoupon: enum.SafeExecIfNotExists,
enum.OperateRedBag: enum.SafeExec,
enum.OperateLuckyBag: enum.SafeExec,
enum.OperationComment: enum.SafeExec,
enum.OperateWindowOpen: enum.SafeExec,
enum.OperateCancel: enum.SafeExec,
enum.Audio: enum.SafeExec,
}

func StartListenKeyBoard() {
KeyBoardGlobalLock.Lock()
defer KeyBoardGlobalLock.Unlock()
wlog.Infof("--- Please press ctrl + shift + q to stop hook ---")

// 加载键盘配置，加载不到就用默认配置
keyboardSettings := setting.GetUserKeyBoardSettingMap()
wlog.Infod("加载键盘配置", keyboardSettings, true)

// TODO，不用GoHook库，调试的时候太卡了，自己实现一个
for bindKey, boardSetting := range keyboardSettings {
// 在循环内部创建新的变量
bindKeyCopy := bindKey
newSettingCopy := boardSetting
str1 := strings.Split(bindKeyCopy, ",")
if len(str1) == 0 {
wlog.Warnf("bindKey %s split error", bindKeyCopy)
continue
}
// 如果keycode.Keycode[str1[0]]存在
if _, ok := keycode.Keycode[str1[0]]; !ok {
// NOTE：hook 钩子函数有BUG，传入不存在的按键会导致任何按键都触发
// 使用mod vendor之后，有可能会重新加载老版本的keycode，会少很多键值
wlog.Warnf("bindKey %s not exist", bindKeyCopy)
continue
}

func(bindKeyCopy string, newSettingCopy setting.UserKeyBoardSetting, str1 []string) {
hook.Register(hook.KeyDown, str1, func(e hook.Event) {
// 检查上次按键时间
// 当前时间 - 上次按键时间 < keyDownInterval
if chrome.ChildCtx == nil || chrome.ChildCtx.Err() != nil {
wlog.Infof("chrome 上下文已关闭，忽略按键，关闭事件监听")
hook.End()
return
}
ii := NewInstructionStructByOperate(newSettingCopy.Operate)
if ii == nil {
wlog.Infof("bind %s Operate %s no config", bindKeyCopy, newSettingCopy.Operate)
} else {
ii.Instance(newSettingCopy.Config.OperateNo, newSettingCopy.Config.OperateNos)
ii.SetBindKey(newSettingCopy.BindKey)
wlog.Infof("load instruction %s", newSettingCopy.BindKey)
execType, ok := ExecMapInstructionStruct[newSettingCopy.Operate]
if !ok {
wlog.Infof("execType %s Operate %s no config", newSettingCopy.BindKey, newSettingCopy.Operate)
} else {
if execType == enum.SafeExec {
instruction.SafeExec(newSettingCopy.Operate, ii)
} else if execType == enum.SafeExecIfNotExists {
instruction.SafeExecIfNotExists(newSettingCopy.Operate, ii)
}
}
}
})
}(bindKeyCopy, newSettingCopy, str1) // 立即调用，传入当前值的副本
}

//关闭程序 内置，不做修改
hook.Register(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
wlog.Infof("ctrl-shift-q")
hook.End()
})

wlog.Infof("启动键盘成功，等待键盘输入指令...")
wlog.Infof("当前Goroutine数量: %d", gopool.GlobalPool.Running())
if gopool.GlobalPool.Running() != 0 {
// 有一个是监听关闭状态的goroutine，在allocator.go中
wlog.Errorf("当前Gopool中Goroutine数量异常，请检查")
}

hookChan = hook.Start()
hookRunning = true
go func() {
defer func() {
if r := recover(); r != nil {
wlog.Panicf("键盘监听发生 panic: %v", r)
}
}()
<-hook.Process(hookChan)
wlog.Infof("键盘监听结束")
hookRunning = false
}()
}

// 停止键盘监听
func StopListenKeyBoard() {
if !hookRunning {
wlog.Infof("键盘监听未在运行")
return
}
wlog.Infof("停止键盘监听")
hook.End()
}


如果以这种方式启动，StartListenKeyBoard是在主线程里吗，还是goroutine里

在goroutine中主线程和其他的goroutine有区别吗，他们不都是goroutine会参与GMP的调度吗。用中文回答