mirror of https://github.com/jetkvm/kvm.git
Run paste/macros in background on their own queue.
Also returns a token for cancellation. Fixed error in length check for macro key state. Removed redundant clear operation.
This commit is contained in:
Marc Brooks
parent
f54b6283d6
commit
faa35a4dca
2
cloud.go
2
cloud.go
|
|
@ -477,7 +477,7 @@ func handleSessionRequest(
|
|||
cloudLogger.Trace().Interface("session", session).Msg("new session accepted")
|
||||
|
||||
// Cancel any ongoing keyboard macro when session changes
|
||||
cancelKeyboardMacro()
|
||||
cancelAllRunningKeyboardMacros()
|
||||
|
||||
currentSession = session
|
||||
_ = wsjson.Write(context.Background(), c, gin.H{"type": "answer", "data": sd})
|
||||
|
|
|
|||
31
hidrpc.go
31
hidrpc.go
|
|
@ -26,20 +26,45 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
|
|||
return
|
||||
}
|
||||
session.hidRPCAvailable = true
|
||||
|
||||
case hidrpc.TypeKeypressReport, hidrpc.TypeKeyboardReport:
|
||||
rpcErr = handleHidRPCKeyboardInput(message)
|
||||
|
||||
case hidrpc.TypeKeyboardMacroReport:
|
||||
keyboardMacroReport, err := message.KeyboardMacroReport()
|
||||
if err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to get keyboard macro report")
|
||||
return
|
||||
}
|
||||
rpcErr = rpcExecuteKeyboardMacro(keyboardMacroReport.Steps)
|
||||
token := rpcExecuteKeyboardMacro(keyboardMacroReport.IsPaste, keyboardMacroReport.Steps)
|
||||
logger.Debug().Str("token", token.String()).Msg("started keyboard macro")
|
||||
message, err := hidrpc.NewKeyboardMacroTokenMessage(token).Marshal()
|
||||
|
||||
if err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to marshal running macro token message")
|
||||
return
|
||||
}
|
||||
if err := session.HidChannel.Send(message); err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to send running macro token message")
|
||||
return
|
||||
}
|
||||
|
||||
case hidrpc.TypeCancelKeyboardMacroReport:
|
||||
rpcCancelKeyboardMacro()
|
||||
return
|
||||
|
||||
case hidrpc.TypeCancelKeyboardMacroByTokenReport:
|
||||
token, err := message.KeyboardMacroToken()
|
||||
if err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to get keyboard macro token")
|
||||
return
|
||||
}
|
||||
rpcCancelKeyboardMacroByToken(token)
|
||||
return
|
||||
|
||||
case hidrpc.TypeKeypressKeepAliveReport:
|
||||
rpcErr = handleHidRPCKeypressKeepAlive(session)
|
||||
|
||||
case hidrpc.TypePointerReport:
|
||||
pointerReport, err := message.PointerReport()
|
||||
if err != nil {
|
||||
|
|
@ -47,6 +72,7 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
|
|||
return
|
||||
}
|
||||
rpcErr = rpcAbsMouseReport(pointerReport.X, pointerReport.Y, pointerReport.Button)
|
||||
|
||||
case hidrpc.TypeMouseReport:
|
||||
mouseReport, err := message.MouseReport()
|
||||
if err != nil {
|
||||
|
|
@ -54,6 +80,7 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
|
|||
return
|
||||
}
|
||||
rpcErr = rpcRelMouseReport(mouseReport.DX, mouseReport.DY, mouseReport.Button)
|
||||
|
||||
default:
|
||||
logger.Warn().Uint8("type", uint8(message.Type())).Msg("unknown HID RPC message type")
|
||||
}
|
||||
|
|
@ -98,7 +125,7 @@ func onHidMessage(msg hidQueueMessage, session *Session) {
|
|||
r <- nil
|
||||
}()
|
||||
select {
|
||||
case <-time.After(30 * time.Second):
|
||||
case <-time.After(1 * time.Second):
|
||||
scopedLogger.Warn().Msg("HID RPC message timed out")
|
||||
case <-r:
|
||||
scopedLogger.Debug().Dur("duration", time.Since(t)).Msg("HID RPC message handled")
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package hidrpc
|
|||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jetkvm/kvm/internal/usbgadget"
|
||||
)
|
||||
|
||||
|
|
@ -22,26 +23,34 @@ const (
|
|||
TypeKeyboardLedState MessageType = 0x32
|
||||
TypeKeydownState MessageType = 0x33
|
||||
TypeKeyboardMacroState MessageType = 0x34
|
||||
TypeCancelKeyboardMacroByTokenReport MessageType = 0x35
|
||||
)
|
||||
|
||||
type QueueIndex int
|
||||
|
||||
const (
|
||||
Version byte = 0x01 // Version of the HID RPC protocol
|
||||
HandshakeQueue int = 0 // Queue index for handshake messages
|
||||
KeyboardQueue int = 1 // Queue index for keyboard and macro messages
|
||||
MouseQueue int = 2 // Queue index for mouse messages
|
||||
MacroQueue int = 3 // Queue index for macro cancel messages
|
||||
OtherQueue int = 4 // Queue index for other messages
|
||||
)
|
||||
|
||||
// GetQueueIndex returns the index of the queue to which the message should be enqueued.
|
||||
func GetQueueIndex(messageType MessageType) int {
|
||||
switch messageType {
|
||||
case TypeHandshake:
|
||||
return 0
|
||||
case TypeKeyboardReport, TypeKeypressReport, TypeKeyboardMacroReport, TypeKeyboardLedState, TypeKeydownState, TypeKeyboardMacroState:
|
||||
return 1
|
||||
return HandshakeQueue
|
||||
case TypeKeyboardReport, TypeKeypressReport, TypeKeyboardLedState, TypeKeydownState, TypeKeyboardMacroState:
|
||||
return KeyboardQueue
|
||||
case TypePointerReport, TypeMouseReport, TypeWheelReport:
|
||||
return 2
|
||||
// we don't want to block the queue for this message
|
||||
case TypeCancelKeyboardMacroReport:
|
||||
return 3
|
||||
return MouseQueue
|
||||
// we don't want to block the queue for these messages
|
||||
case TypeKeyboardMacroReport, TypeCancelKeyboardMacroReport, TypeCancelKeyboardMacroByTokenReport:
|
||||
return MacroQueue
|
||||
default:
|
||||
return 3
|
||||
return OtherQueue
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -121,3 +130,13 @@ func NewKeyboardMacroStateMessage(state bool, isPaste bool) *Message {
|
|||
d: data,
|
||||
}
|
||||
}
|
||||
|
||||
// NewKeyboardMacroTokenMessage creates a new keyboard macro token message.
|
||||
func NewKeyboardMacroTokenMessage(token uuid.UUID) *Message {
|
||||
data, _ := token.MarshalBinary()
|
||||
|
||||
return &Message{
|
||||
t: TypeKeyboardMacroState,
|
||||
d: data,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@ package hidrpc
|
|||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// Message ..
|
||||
|
|
@ -23,6 +25,9 @@ func (m *Message) Type() MessageType {
|
|||
func (m *Message) String() string {
|
||||
switch m.t {
|
||||
case TypeHandshake:
|
||||
if len(m.d) != 0 {
|
||||
return fmt.Sprintf("Handshake{Malformed: %v}", m.d)
|
||||
}
|
||||
return "Handshake"
|
||||
case TypeKeypressReport:
|
||||
if len(m.d) < 2 {
|
||||
|
|
@ -45,12 +50,45 @@ func (m *Message) String() string {
|
|||
}
|
||||
return fmt.Sprintf("MouseReport{DX: %d, DY: %d, Button: %d}", m.d[0], m.d[1], m.d[2])
|
||||
case TypeKeypressKeepAliveReport:
|
||||
if len(m.d) != 0 {
|
||||
return fmt.Sprintf("KeypressKeepAliveReport{Malformed: %v}", m.d)
|
||||
}
|
||||
return "KeypressKeepAliveReport"
|
||||
case TypeWheelReport:
|
||||
if len(m.d) < 3 {
|
||||
return fmt.Sprintf("WheelReport{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("WheelReport{Vertical: %d, Horizontal: %d}", int8(m.d[0]), int8(m.d[1]))
|
||||
case TypeKeyboardMacroReport:
|
||||
if len(m.d) < 5 {
|
||||
return fmt.Sprintf("KeyboardMacroReport{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("KeyboardMacroReport{IsPaste: %v, Length: %d}", m.d[0] == uint8(1), binary.BigEndian.Uint32(m.d[1:5]))
|
||||
case TypeCancelKeyboardMacroReport:
|
||||
if len(m.d) != 0 {
|
||||
return fmt.Sprintf("CancelKeyboardMacroReport{Malformed: %v}", m.d)
|
||||
}
|
||||
return "CancelKeyboardMacroReport"
|
||||
case TypeCancelKeyboardMacroByTokenReport:
|
||||
if len(m.d) != 16 {
|
||||
return fmt.Sprintf("CancelKeyboardMacroByTokenReport{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("CancelKeyboardMacroByTokenReport{Token: %s}", uuid.Must(uuid.FromBytes(m.d)).String())
|
||||
case TypeKeyboardLedState:
|
||||
if len(m.d) < 1 {
|
||||
return fmt.Sprintf("KeyboardLedState{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("KeyboardLedState{State: %d}", m.d[0])
|
||||
case TypeKeydownState:
|
||||
if len(m.d) < 1 {
|
||||
return fmt.Sprintf("KeydownState{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("KeydownState{State: %d}", m.d[0])
|
||||
case TypeKeyboardMacroState:
|
||||
if len(m.d) < 2 {
|
||||
return fmt.Sprintf("KeyboardMacroState{Malformed: %v}", m.d)
|
||||
}
|
||||
return fmt.Sprintf("KeyboardMacroState{State: %v, IsPaste: %v}", m.d[0] == uint8(1), m.d[1] == uint8(1))
|
||||
default:
|
||||
return fmt.Sprintf("Unknown{Type: %d, Data: %v}", m.t, m.d)
|
||||
}
|
||||
|
|
@ -67,7 +105,9 @@ func (m *Message) KeypressReport() (KeypressReport, error) {
|
|||
if m.t != TypeKeypressReport {
|
||||
return KeypressReport{}, fmt.Errorf("invalid message type: %d", m.t)
|
||||
}
|
||||
|
||||
if len(m.d) < 2 {
|
||||
return KeypressReport{}, fmt.Errorf("invalid message data length: %d", len(m.d))
|
||||
}
|
||||
return KeypressReport{
|
||||
Key: m.d[0],
|
||||
Press: m.d[1] == uint8(1),
|
||||
|
|
@ -95,7 +135,7 @@ func (m *Message) KeyboardReport() (KeyboardReport, error) {
|
|||
// Macro ..
|
||||
type KeyboardMacroStep struct {
|
||||
Modifier byte // 1 byte
|
||||
Keys []byte // 6 bytes: hidKeyBufferSize
|
||||
Keys []byte // 6 bytes: HidKeyBufferSize
|
||||
Delay uint16 // 2 bytes
|
||||
}
|
||||
type KeyboardMacroReport struct {
|
||||
|
|
@ -105,7 +145,7 @@ type KeyboardMacroReport struct {
|
|||
}
|
||||
|
||||
// HidKeyBufferSize is the size of the keys buffer in the keyboard report.
|
||||
const HidKeyBufferSize = 6
|
||||
const HidKeyBufferSize int = 6
|
||||
|
||||
// KeyboardMacroReport returns the keyboard macro report from the message.
|
||||
func (m *Message) KeyboardMacroReport() (KeyboardMacroReport, error) {
|
||||
|
|
@ -205,3 +245,20 @@ func (m *Message) KeyboardMacroState() (KeyboardMacroState, error) {
|
|||
IsPaste: m.d[1] == uint8(1),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// KeyboardMacroToken returns the keyboard macro token UUID from the message.
|
||||
func (m *Message) KeyboardMacroToken() (uuid.UUID, error) {
|
||||
if m.t != TypeCancelKeyboardMacroByTokenReport {
|
||||
return uuid.Nil, fmt.Errorf("invalid message type: %d", m.t)
|
||||
}
|
||||
|
||||
if len(m.d) == 0 {
|
||||
return uuid.Nil, nil
|
||||
}
|
||||
|
||||
if len(m.d) != 16 {
|
||||
return uuid.Nil, fmt.Errorf("invalid UUID length: %d", len(m.d))
|
||||
}
|
||||
|
||||
return uuid.FromBytes(m.d)
|
||||
}
|
||||
|
|
|
|||
132
jsonrpc.go
132
jsonrpc.go
|
|
@ -1,7 +1,6 @@
|
|||
package kvm
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
|
|
@ -14,6 +13,7 @@ import (
|
|||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/pion/webrtc/v4"
|
||||
"github.com/rs/zerolog"
|
||||
"go.bug.st/serial"
|
||||
|
|
@ -1070,68 +1070,121 @@ func rpcSetLocalLoopbackOnly(enabled bool) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
type RunningMacro struct {
|
||||
cancel context.CancelFunc
|
||||
isPaste bool
|
||||
}
|
||||
|
||||
var (
|
||||
keyboardMacroCancel context.CancelFunc
|
||||
keyboardMacroCancelMap map[uuid.UUID]RunningMacro
|
||||
keyboardMacroLock sync.Mutex
|
||||
)
|
||||
|
||||
// cancelKeyboardMacro cancels any ongoing keyboard macro execution
|
||||
func cancelKeyboardMacro() {
|
||||
func init() {
|
||||
keyboardMacroCancelMap = make(map[uuid.UUID]RunningMacro)
|
||||
}
|
||||
|
||||
func addKeyboardMacro(isPaste bool, cancel context.CancelFunc) uuid.UUID {
|
||||
keyboardMacroLock.Lock()
|
||||
defer keyboardMacroLock.Unlock()
|
||||
|
||||
if keyboardMacroCancel != nil {
|
||||
keyboardMacroCancel()
|
||||
logger.Info().Msg("canceled keyboard macro")
|
||||
keyboardMacroCancel = nil
|
||||
token := uuid.New() // Generate a unique token
|
||||
keyboardMacroCancelMap[token] = RunningMacro{
|
||||
isPaste: isPaste,
|
||||
cancel: cancel,
|
||||
}
|
||||
return token
|
||||
}
|
||||
|
||||
func setKeyboardMacroCancel(cancel context.CancelFunc) {
|
||||
func removeRunningKeyboardMacro(token uuid.UUID) {
|
||||
keyboardMacroLock.Lock()
|
||||
defer keyboardMacroLock.Unlock()
|
||||
|
||||
keyboardMacroCancel = cancel
|
||||
delete(keyboardMacroCancelMap, token)
|
||||
}
|
||||
|
||||
func rpcExecuteKeyboardMacro(macro []hidrpc.KeyboardMacroStep) error {
|
||||
cancelKeyboardMacro()
|
||||
func cancelRunningKeyboardMacro(token uuid.UUID) {
|
||||
keyboardMacroLock.Lock()
|
||||
defer keyboardMacroLock.Unlock()
|
||||
|
||||
if runningMacro, exists := keyboardMacroCancelMap[token]; exists {
|
||||
runningMacro.cancel()
|
||||
delete(keyboardMacroCancelMap, token)
|
||||
logger.Info().Interface("token", token).Msg("canceled keyboard macro by token")
|
||||
} else {
|
||||
logger.Debug().Interface("token", token).Msg("no running keyboard macro found for token")
|
||||
}
|
||||
}
|
||||
|
||||
func cancelAllRunningKeyboardMacros() {
|
||||
keyboardMacroLock.Lock()
|
||||
defer keyboardMacroLock.Unlock()
|
||||
|
||||
for token, runningMacro := range keyboardMacroCancelMap {
|
||||
runningMacro.cancel()
|
||||
delete(keyboardMacroCancelMap, token)
|
||||
logger.Info().Interface("token", token).Msg("cancelled keyboard macro")
|
||||
}
|
||||
}
|
||||
|
||||
func reportRunningMacrosState() {
|
||||
if currentSession != nil {
|
||||
keyboardMacroLock.Lock()
|
||||
defer keyboardMacroLock.Unlock()
|
||||
|
||||
isPaste := false
|
||||
anyRunning := false
|
||||
for _, runningMacro := range keyboardMacroCancelMap {
|
||||
anyRunning = true
|
||||
if runningMacro.isPaste {
|
||||
isPaste = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
state := hidrpc.KeyboardMacroState{
|
||||
State: anyRunning,
|
||||
IsPaste: isPaste,
|
||||
}
|
||||
|
||||
currentSession.reportHidRPCKeyboardMacroState(state)
|
||||
}
|
||||
}
|
||||
|
||||
func rpcExecuteKeyboardMacro(isPaste bool, macro []hidrpc.KeyboardMacroStep) uuid.UUID {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
setKeyboardMacroCancel(cancel)
|
||||
token := addKeyboardMacro(isPaste, cancel)
|
||||
reportRunningMacrosState()
|
||||
|
||||
s := hidrpc.KeyboardMacroState{
|
||||
State: true,
|
||||
IsPaste: true,
|
||||
go func() {
|
||||
defer reportRunningMacrosState() // this executes last, so the map is already updated
|
||||
defer removeRunningKeyboardMacro(token) // this executes first, to update the map
|
||||
|
||||
err := executeKeyboardMacro(ctx, isPaste, macro)
|
||||
if err != nil {
|
||||
logger.Error().Err(err).Interface("token", token).Bool("isPaste", isPaste).Msg("keyboard macro execution failed")
|
||||
}
|
||||
}()
|
||||
|
||||
if currentSession != nil {
|
||||
currentSession.reportHidRPCKeyboardMacroState(s)
|
||||
}
|
||||
|
||||
err := rpcDoExecuteKeyboardMacro(ctx, macro)
|
||||
|
||||
setKeyboardMacroCancel(nil)
|
||||
|
||||
s.State = false
|
||||
if currentSession != nil {
|
||||
currentSession.reportHidRPCKeyboardMacroState(s)
|
||||
}
|
||||
|
||||
return err
|
||||
return token
|
||||
}
|
||||
|
||||
func rpcCancelKeyboardMacro() {
|
||||
cancelKeyboardMacro()
|
||||
defer reportRunningMacrosState()
|
||||
cancelAllRunningKeyboardMacros()
|
||||
}
|
||||
|
||||
var keyboardClearStateKeys = make([]byte, hidrpc.HidKeyBufferSize)
|
||||
func rpcCancelKeyboardMacroByToken(token uuid.UUID) {
|
||||
defer reportRunningMacrosState()
|
||||
|
||||
func isClearKeyStep(step hidrpc.KeyboardMacroStep) bool {
|
||||
return step.Modifier == 0 && bytes.Equal(step.Keys, keyboardClearStateKeys)
|
||||
if token == uuid.Nil {
|
||||
cancelAllRunningKeyboardMacros()
|
||||
} else {
|
||||
cancelRunningKeyboardMacro(token)
|
||||
}
|
||||
}
|
||||
|
||||
func rpcDoExecuteKeyboardMacro(ctx context.Context, macro []hidrpc.KeyboardMacroStep) error {
|
||||
func executeKeyboardMacro(ctx context.Context, isPaste bool, macro []hidrpc.KeyboardMacroStep) error {
|
||||
logger.Debug().Int("macro_steps", len(macro)).Msg("Executing keyboard macro")
|
||||
|
||||
// don't report keyboard state changes while executing the macro
|
||||
|
|
@ -1143,15 +1196,10 @@ func rpcDoExecuteKeyboardMacro(ctx context.Context, macro []hidrpc.KeyboardMacro
|
|||
|
||||
err := rpcKeyboardReport(step.Modifier, step.Keys)
|
||||
if err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to execute keyboard macro")
|
||||
logger.Warn().Err(err).Int("step", i).Msg("failed to execute keyboard macro")
|
||||
return err
|
||||
}
|
||||
|
||||
// notify the device that the keyboard state is being cleared
|
||||
if isClearKeyStep(step) {
|
||||
gadget.UpdateKeysDown(0, keyboardClearStateKeys)
|
||||
}
|
||||
|
||||
// Use context-aware sleep that can be cancelled
|
||||
select {
|
||||
case <-time.After(delay):
|
||||
|
|
@ -1159,7 +1207,7 @@ func rpcDoExecuteKeyboardMacro(ctx context.Context, macro []hidrpc.KeyboardMacro
|
|||
case <-ctx.Done():
|
||||
// make sure keyboard state is reset and the client gets notified
|
||||
gadget.ResumeSuspendKeyDownMessages()
|
||||
err := rpcKeyboardReport(0, keyboardClearStateKeys)
|
||||
err := rpcKeyboardReport(0, make([]byte, hidrpc.HidKeyBufferSize))
|
||||
if err != nil {
|
||||
logger.Warn().Err(err).Msg("failed to reset keyboard state")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@
|
|||
"recharts": "^3.2.1",
|
||||
"tailwind-merge": "^3.3.1",
|
||||
"usehooks-ts": "^3.1.1",
|
||||
"uuid": "^13.0.0",
|
||||
"validator": "^13.15.15",
|
||||
"zustand": "^4.5.2"
|
||||
},
|
||||
|
|
@ -6880,6 +6881,19 @@
|
|||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/uuid": {
|
||||
"version": "13.0.0",
|
||||
"resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz",
|
||||
"integrity": "sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==",
|
||||
"funding": [
|
||||
"https://github.com/sponsors/broofa",
|
||||
"https://github.com/sponsors/ctavan"
|
||||
],
|
||||
"license": "MIT",
|
||||
"bin": {
|
||||
"uuid": "dist-node/bin/uuid"
|
||||
}
|
||||
},
|
||||
"node_modules/validator": {
|
||||
"version": "13.15.15",
|
||||
"resolved": "https://registry.npmjs.org/validator/-/validator-13.15.15.tgz",
|
||||
|
|
|
|||
|
|
@ -48,6 +48,7 @@
|
|||
"recharts": "^3.2.1",
|
||||
"tailwind-merge": "^3.3.1",
|
||||
"usehooks-ts": "^3.1.1",
|
||||
"uuid": "^13.0.0",
|
||||
"validator": "^13.15.15",
|
||||
"zustand": "^4.5.2"
|
||||
},
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
import { parse as uuidParse , stringify as uuidStringify } from "uuid";
|
||||
|
||||
import { hidKeyBufferSize, KeyboardLedState, KeysDownState } from "./stores";
|
||||
|
||||
export const HID_RPC_MESSAGE_TYPES = {
|
||||
|
|
@ -13,6 +15,7 @@ export const HID_RPC_MESSAGE_TYPES = {
|
|||
KeyboardLedState: 0x32,
|
||||
KeysDownState: 0x33,
|
||||
KeyboardMacroState: 0x34,
|
||||
CancelKeyboardMacroByTokenReport: 0x35,
|
||||
}
|
||||
|
||||
export type HidRpcMessageType = typeof HID_RPC_MESSAGE_TYPES[keyof typeof HID_RPC_MESSAGE_TYPES];
|
||||
|
|
@ -299,7 +302,7 @@ export class KeyboardMacroStateMessage extends RpcMessage {
|
|||
}
|
||||
|
||||
public static unmarshal(data: Uint8Array): KeyboardMacroStateMessage | undefined {
|
||||
if (data.length < 1) {
|
||||
if (data.length < 2) {
|
||||
throw new Error(`Invalid keyboard macro state report message length: ${data.length}`);
|
||||
}
|
||||
|
||||
|
|
@ -378,13 +381,30 @@ export class PointerReportMessage extends RpcMessage {
|
|||
}
|
||||
|
||||
export class CancelKeyboardMacroReportMessage extends RpcMessage {
|
||||
token: string;
|
||||
|
||||
constructor() {
|
||||
constructor(token: string) {
|
||||
super(HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport);
|
||||
this.token = (token == null || token === undefined || token === "")
|
||||
? "00000000-0000-0000-0000-000000000000"
|
||||
: token;
|
||||
}
|
||||
|
||||
marshal(): Uint8Array {
|
||||
return new Uint8Array([this.messageType]);
|
||||
const tokenBytes = uuidParse(this.token);
|
||||
return new Uint8Array([this.messageType, ...tokenBytes]);
|
||||
}
|
||||
|
||||
public static unmarshal(data: Uint8Array): CancelKeyboardMacroReportMessage | undefined {
|
||||
if (data.length == 0) {
|
||||
return new CancelKeyboardMacroReportMessage("00000000-0000-0000-0000-000000000000");
|
||||
}
|
||||
|
||||
if (data.length != 16) {
|
||||
throw new Error(`Invalid cancel message length: ${data.length}`);
|
||||
}
|
||||
|
||||
return new CancelKeyboardMacroReportMessage(uuidStringify(data.slice(0, 16)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -430,6 +450,7 @@ export const messageRegistry = {
|
|||
[HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport]: CancelKeyboardMacroReportMessage,
|
||||
[HID_RPC_MESSAGE_TYPES.KeyboardMacroState]: KeyboardMacroStateMessage,
|
||||
[HID_RPC_MESSAGE_TYPES.KeypressKeepAliveReport]: KeypressKeepAliveMessage,
|
||||
[HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroByTokenReport]: CancelKeyboardMacroReportMessage,
|
||||
}
|
||||
|
||||
export const unmarshalHidRpcMessage = (data: Uint8Array): RpcMessage | undefined => {
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
|
|||
|
||||
const cancelOngoingKeyboardMacro = useCallback(
|
||||
() => {
|
||||
sendMessage(new CancelKeyboardMacroReportMessage());
|
||||
sendMessage(new CancelKeyboardMacroReportMessage(""));
|
||||
},
|
||||
[sendMessage],
|
||||
);
|
||||
|
|
|
|||
2
web.go
2
web.go
|
|
@ -230,7 +230,7 @@ func handleWebRTCSession(c *gin.Context) {
|
|||
}
|
||||
|
||||
// Cancel any ongoing keyboard macro when session changes
|
||||
cancelKeyboardMacro()
|
||||
cancelAllRunningKeyboardMacros()
|
||||
|
||||
currentSession = session
|
||||
c.JSON(http.StatusOK, gin.H{"sd": sd})
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ func (s *Session) initQueues() {
|
|||
defer s.hidQueueLock.Unlock()
|
||||
|
||||
s.hidQueue = make([]chan hidQueueMessage, 0)
|
||||
for i := 0; i < 4; i++ {
|
||||
for i := 0; i <= hidrpc.OtherQueue; i++ {
|
||||
q := make(chan hidQueueMessage, 256)
|
||||
s.hidQueue = append(s.hidQueue, q)
|
||||
}
|
||||
|
|
@ -163,7 +163,7 @@ func getOnHidMessageHandler(session *Session, scopedLogger *zerolog.Logger, chan
|
|||
queueIndex := hidrpc.GetQueueIndex(hidrpc.MessageType(msg.Data[0]))
|
||||
if queueIndex >= len(session.hidQueue) || queueIndex < 0 {
|
||||
l.Warn().Int("queueIndex", queueIndex).Msg("received data in HID RPC message handler, but queue index not found")
|
||||
queueIndex = 3
|
||||
queueIndex = hidrpc.OtherQueue
|
||||
}
|
||||
|
||||
queue := session.hidQueue[queueIndex]
|
||||
|
|
@ -328,7 +328,7 @@ func newSession(config SessionConfig) (*Session, error) {
|
|||
scopedLogger.Debug().Msg("ICE Connection State is closed, unmounting virtual media")
|
||||
if session == currentSession {
|
||||
// Cancel any ongoing keyboard report multi when session closes
|
||||
cancelKeyboardMacro()
|
||||
cancelAllRunningKeyboardMacros()
|
||||
currentSession = nil
|
||||
}
|
||||
// Stop RPC processor
|
||||
|
|
|
|||
Loading…
Reference in New Issue