diff --git a/ui/src/components/Ipv6NetworkCard.tsx b/ui/src/components/Ipv6NetworkCard.tsx
index a31b78e0..0cfacc6d 100644
--- a/ui/src/components/Ipv6NetworkCard.tsx
+++ b/ui/src/components/Ipv6NetworkCard.tsx
@@ -17,7 +17,7 @@ export default function Ipv6NetworkCard({
- {networkState?.dhcp_lease?.ip && (
+ {networkState?.ipv6_link_local && (
Link-local
diff --git a/ui/src/components/WebRTCVideo.tsx b/ui/src/components/WebRTCVideo.tsx
index b26dde47..3d506914 100644
--- a/ui/src/components/WebRTCVideo.tsx
+++ b/ui/src/components/WebRTCVideo.tsx
@@ -215,7 +215,7 @@ export default function WebRTCVideo({ microphone }: WebRTCVideoProps) {
if (!isFullscreenEnabled || !videoElm.current) return;
// per https://wicg.github.io/keyboard-lock/#system-key-press-handler
- // If keyboard lock is activated after fullscreen is already in effect, then the user my
+ // If keyboard lock is activated after fullscreen is already in effect, then the user my
// see multiple messages about how to exit fullscreen. For this reason, we recommend that
// developers call lock() before they enter fullscreen:
await requestKeyboardLock();
@@ -262,6 +262,7 @@ export default function WebRTCVideo({ microphone }: WebRTCVideoProps) {
const keyDownHandler = useCallback(
(e: KeyboardEvent) => {
e.preventDefault();
+ if (e.repeat) return;
const code = getAdjustedKeyCode(e);
const hidKey = keys[code];
diff --git a/ui/src/components/popovers/PasteModal.tsx b/ui/src/components/popovers/PasteModal.tsx
index 077759b7..6f224eb5 100644
--- a/ui/src/components/popovers/PasteModal.tsx
+++ b/ui/src/components/popovers/PasteModal.tsx
@@ -1,40 +1,44 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { LuCornerDownLeft } from "react-icons/lu";
-import { ExclamationCircleIcon } from "@heroicons/react/16/solid";
import { useClose } from "@headlessui/react";
+import { ExclamationCircleIcon } from "@heroicons/react/16/solid";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { LuCornerDownLeft } from "react-icons/lu";
-import { Button } from "@components/Button";
-import { GridCard } from "@components/Card";
-import { TextAreaWithLabel } from "@components/TextArea";
-import { SettingsPageHeader } from "@components/SettingsPageheader";
+import { cx } from "@/cva.config";
+import { useHidStore, useSettingsStore, useUiStore } from "@/hooks/stores";
import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
-import { useHidStore, useRTCStore, useUiStore, useSettingsStore } from "@/hooks/stores";
-import { keys, modifiers } from "@/keyboardMappings";
-import { KeyStroke } from "@/keyboardLayouts";
+import useKeyboard, { type MacroStep } from "@/hooks/useKeyboard";
import useKeyboardLayout from "@/hooks/useKeyboardLayout";
import notifications from "@/notifications";
+import { Button } from "@components/Button";
+import { GridCard } from "@components/Card";
+import { InputFieldWithLabel } from "@components/InputField";
+import { SettingsPageHeader } from "@components/SettingsPageheader";
+import { TextAreaWithLabel } from "@components/TextArea";
-const hidKeyboardPayload = (modifier: number, keys: number[]) => {
- return { modifier, keys };
-};
-
-const modifierCode = (shift?: boolean, altRight?: boolean) => {
- return (shift ? modifiers.ShiftLeft : 0)
- | (altRight ? modifiers.AltRight : 0)
-}
-const noModifier = 0
+// uint32 max value / 4
+const pasteMaxLength = 1073741824;
export default function PasteModal() {
const TextAreaRef = useRef(null);
- const { setPasteModeEnabled } = useHidStore();
+ const { isPasteInProgress } = useHidStore();
const { setDisableVideoFocusTrap } = useUiStore();
const { send } = useJsonRpc();
- const { rpcDataChannel } = useRTCStore();
+ const { executeMacro, cancelExecuteMacro } = useKeyboard();
const [invalidChars, setInvalidChars] = useState([]);
+ const [delayValue, setDelayValue] = useState(100);
+ const delay = useMemo(() => {
+ if (delayValue < 50 || delayValue > 65534) {
+ return 100;
+ }
+ return delayValue;
+ }, [delayValue]);
const close = useClose();
+ const debugMode = useSettingsStore(state => state.debugMode);
+ const delayClassName = useMemo(() => debugMode ? "" : "hidden", [debugMode]);
+
const { setKeyboardLayout } = useSettingsStore();
const { selectedKeyboard } = useKeyboardLayout();
@@ -46,21 +50,19 @@ export default function PasteModal() {
}, [send, setKeyboardLayout]);
const onCancelPasteMode = useCallback(() => {
- setPasteModeEnabled(false);
+ cancelExecuteMacro();
setDisableVideoFocusTrap(false);
setInvalidChars([]);
- }, [setDisableVideoFocusTrap, setPasteModeEnabled]);
+ }, [setDisableVideoFocusTrap, cancelExecuteMacro]);
const onConfirmPaste = useCallback(async () => {
- setPasteModeEnabled(false);
- setDisableVideoFocusTrap(false);
-
- if (rpcDataChannel?.readyState !== "open" || !TextAreaRef.current) return;
- if (!selectedKeyboard) return;
+ if (!TextAreaRef.current || !selectedKeyboard) return;
const text = TextAreaRef.current.value;
try {
+ const macroSteps: MacroStep[] = [];
+
for (const char of text) {
const keyprops = selectedKeyboard.chars[char];
if (!keyprops) continue;
@@ -70,39 +72,41 @@ export default function PasteModal() {
// if this is an accented character, we need to send that accent FIRST
if (accentKey) {
- await sendKeystroke({modifier: modifierCode(accentKey.shift, accentKey.altRight), keys: [ keys[accentKey.key] ] })
+ const accentModifiers: string[] = [];
+ if (accentKey.shift) accentModifiers.push("ShiftLeft");
+ if (accentKey.altRight) accentModifiers.push("AltRight");
+
+ macroSteps.push({
+ keys: [String(accentKey.key)],
+ modifiers: accentModifiers.length > 0 ? accentModifiers : null,
+ delay,
+ });
}
// now send the actual key
- await sendKeystroke({ modifier: modifierCode(shift, altRight), keys: [ keys[key] ]});
+ const modifiers: string[] = [];
+ if (shift) modifiers.push("ShiftLeft");
+ if (altRight) modifiers.push("AltRight");
+
+ macroSteps.push({
+ keys: [String(key)],
+ modifiers: modifiers.length > 0 ? modifiers : null,
+ delay
+ });
// if what was requested was a dead key, we need to send an unmodified space to emit
// just the accent character
- if (deadKey) {
- await sendKeystroke({ modifier: noModifier, keys: [ keys["Space"] ] });
- }
+ if (deadKey) macroSteps.push({ keys: ["Space"], modifiers: null, delay });
+ }
- // now send a message with no keys down to "release" the keys
- await sendKeystroke({ modifier: 0, keys: [] });
+ if (macroSteps.length > 0) {
+ await executeMacro(macroSteps);
}
} catch (error) {
console.error("Failed to paste text:", error);
notifications.error("Failed to paste text");
}
-
- async function sendKeystroke(stroke: KeyStroke) {
- await new Promise((resolve, reject) => {
- send(
- "keyboardReport",
- hidKeyboardPayload(stroke.modifier, stroke.keys),
- params => {
- if ("error" in params) return reject(params.error);
- resolve();
- }
- );
- });
- }
- }, [selectedKeyboard, rpcDataChannel?.readyState, send, setDisableVideoFocusTrap, setPasteModeEnabled]);
+ }, [selectedKeyboard, executeMacro, delay]);
useEffect(() => {
if (TextAreaRef.current) {
@@ -122,19 +126,25 @@ export default function PasteModal() {
/>
-
e.stopPropagation()} onKeyDown={e => e.stopPropagation()}>
+
e.stopPropagation()}
+ onKeyDown={e => e.stopPropagation()} onKeyDownCapture={e => e.stopPropagation()}
+ onKeyUpCapture={e => e.stopPropagation()}
+ >
e.stopPropagation()}
+ maxLength={pasteMaxLength}
onKeyDown={e => {
e.stopPropagation();
if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
@@ -171,9 +181,31 @@ export default function PasteModal() {
)}
+
+
{
+ setDelayValue(parseInt(e.target.value, 10));
+ }}
+ />
+ {delayValue < 50 || delayValue > 65534 && (
+
+
+
+ Delay must be between 50 and 65534
+
+
+ )}
+
- Sending text using keyboard layout: {selectedKeyboard.isoCode}-{selectedKeyboard.name}
+ Sending text using keyboard layout: {selectedKeyboard.isoCode}-
+ {selectedKeyboard.name}
@@ -181,7 +213,7 @@ export default function PasteModal() {
diff --git a/ui/src/hooks/hidRpc.ts b/ui/src/hooks/hidRpc.ts
index 20b8a108..823384ff 100644
--- a/ui/src/hooks/hidRpc.ts
+++ b/ui/src/hooks/hidRpc.ts
@@ -1,4 +1,4 @@
-import { KeyboardLedState, KeysDownState } from "./stores";
+import { hidKeyBufferSize, KeyboardLedState, KeysDownState } from "./stores";
export const HID_RPC_MESSAGE_TYPES = {
Handshake: 0x01,
@@ -6,9 +6,13 @@ export const HID_RPC_MESSAGE_TYPES = {
PointerReport: 0x03,
WheelReport: 0x04,
KeypressReport: 0x05,
+ KeypressKeepAliveReport: 0x09,
MouseReport: 0x06,
+ KeyboardMacroReport: 0x07,
+ CancelKeyboardMacroReport: 0x08,
KeyboardLedState: 0x32,
KeysDownState: 0x33,
+ KeyboardMacroState: 0x34,
}
export type HidRpcMessageType = typeof HID_RPC_MESSAGE_TYPES[keyof typeof HID_RPC_MESSAGE_TYPES];
@@ -28,7 +32,31 @@ const fromInt32toUint8 = (n: number) => {
(n >> 24) & 0xFF,
(n >> 16) & 0xFF,
(n >> 8) & 0xFF,
- (n >> 0) & 0xFF,
+ n & 0xFF,
+ ]);
+};
+
+const fromUint16toUint8 = (n: number) => {
+ if (n > 65535 || n < 0) {
+ throw new Error(`Number ${n} is not within the uint16 range`);
+ }
+
+ return new Uint8Array([
+ (n >> 8) & 0xFF,
+ n & 0xFF,
+ ]);
+};
+
+const fromUint32toUint8 = (n: number) => {
+ if (n > 4294967295 || n < 0) {
+ throw new Error(`Number ${n} is not within the uint32 range`);
+ }
+
+ return new Uint8Array([
+ (n >> 24) & 0xFF,
+ (n >> 16) & 0xFF,
+ (n >> 8) & 0xFF,
+ n & 0xFF,
]);
};
@@ -37,7 +65,7 @@ const fromInt8ToUint8 = (n: number) => {
throw new Error(`Number ${n} is not within the int8 range`);
}
- return (n >> 0) & 0xFF;
+ return n & 0xFF;
};
const keyboardLedStateMasks = {
@@ -186,6 +214,99 @@ export class KeyboardReportMessage extends RpcMessage {
}
}
+export interface KeyboardMacroStep extends KeysDownState {
+ delay: number;
+}
+
+export class KeyboardMacroReportMessage extends RpcMessage {
+ isPaste: boolean;
+ stepCount: number;
+ steps: KeyboardMacroStep[];
+
+ KEYS_LENGTH = hidKeyBufferSize;
+
+ constructor(isPaste: boolean, stepCount: number, steps: KeyboardMacroStep[]) {
+ super(HID_RPC_MESSAGE_TYPES.KeyboardMacroReport);
+ this.isPaste = isPaste;
+ this.stepCount = stepCount;
+ this.steps = steps;
+ }
+
+ marshal(): Uint8Array {
+ // validate if length is correct
+ if (this.stepCount !== this.steps.length) {
+ throw new Error(`Length ${this.stepCount} is not equal to the number of steps ${this.steps.length}`);
+ }
+
+ const data = new Uint8Array(this.stepCount * 9 + 6);
+ data.set(new Uint8Array([
+ this.messageType,
+ this.isPaste ? 1 : 0,
+ ...fromUint32toUint8(this.stepCount),
+ ]), 0);
+
+ for (let i = 0; i < this.stepCount; i++) {
+ const step = this.steps[i];
+ if (!withinUint8Range(step.modifier)) {
+ throw new Error(`Modifier ${step.modifier} is not within the uint8 range`);
+ }
+
+ // Ensure the keys are within the KEYS_LENGTH range
+ const keys = step.keys;
+ if (keys.length > this.KEYS_LENGTH) {
+ throw new Error(`Keys ${keys} is not within the hidKeyBufferSize range`);
+ } else if (keys.length < this.KEYS_LENGTH) {
+ keys.push(...Array(this.KEYS_LENGTH - keys.length).fill(0));
+ }
+
+ for (const key of keys) {
+ if (!withinUint8Range(key)) {
+ throw new Error(`Key ${key} is not within the uint8 range`);
+ }
+ }
+
+ const macroBinary = new Uint8Array([
+ step.modifier,
+ ...keys,
+ ...fromUint16toUint8(step.delay),
+ ]);
+ const offset = 6 + i * 9;
+
+
+ data.set(macroBinary, offset);
+ }
+
+ return data;
+ }
+}
+
+export class KeyboardMacroStateMessage extends RpcMessage {
+ state: boolean;
+ isPaste: boolean;
+
+ constructor(state: boolean, isPaste: boolean) {
+ super(HID_RPC_MESSAGE_TYPES.KeyboardMacroState);
+ this.state = state;
+ this.isPaste = isPaste;
+ }
+
+ marshal(): Uint8Array {
+ return new Uint8Array([
+ this.messageType,
+ this.state ? 1 : 0,
+ this.isPaste ? 1 : 0,
+ ]);
+ }
+
+ public static unmarshal(data: Uint8Array): KeyboardMacroStateMessage | undefined {
+ if (data.length < 1) {
+ throw new Error(`Invalid keyboard macro state report message length: ${data.length}`);
+ }
+
+ return new KeyboardMacroStateMessage(data[0] === 1, data[1] === 1);
+ }
+}
+
export class KeyboardLedStateMessage extends RpcMessage {
keyboardLedState: KeyboardLedState;
@@ -256,6 +377,17 @@ export class PointerReportMessage extends RpcMessage {
}
}
+export class CancelKeyboardMacroReportMessage extends RpcMessage {
+
+ constructor() {
+ super(HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport);
+ }
+
+ marshal(): Uint8Array {
+ return new Uint8Array([this.messageType]);
+ }
+}
+
export class MouseReportMessage extends RpcMessage {
dx: number;
dy: number;
@@ -278,12 +410,26 @@ export class MouseReportMessage extends RpcMessage {
}
}
+export class KeypressKeepAliveMessage extends RpcMessage {
+ constructor() {
+ super(HID_RPC_MESSAGE_TYPES.KeypressKeepAliveReport);
+ }
+
+ marshal(): Uint8Array {
+ return new Uint8Array([this.messageType]);
+ }
+}
+
export const messageRegistry = {
[HID_RPC_MESSAGE_TYPES.Handshake]: HandshakeMessage,
[HID_RPC_MESSAGE_TYPES.KeysDownState]: KeysDownStateMessage,
[HID_RPC_MESSAGE_TYPES.KeyboardLedState]: KeyboardLedStateMessage,
[HID_RPC_MESSAGE_TYPES.KeyboardReport]: KeyboardReportMessage,
[HID_RPC_MESSAGE_TYPES.KeypressReport]: KeypressReportMessage,
+ [HID_RPC_MESSAGE_TYPES.KeyboardMacroReport]: KeyboardMacroReportMessage,
+ [HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport]: CancelKeyboardMacroReportMessage,
+ [HID_RPC_MESSAGE_TYPES.KeyboardMacroState]: KeyboardMacroStateMessage,
+ [HID_RPC_MESSAGE_TYPES.KeypressKeepAliveReport]: KeypressKeepAliveMessage,
}
export const unmarshalHidRpcMessage = (data: Uint8Array): RpcMessage | undefined => {
diff --git a/ui/src/hooks/stores.ts b/ui/src/hooks/stores.ts
index c204a827..e43e5137 100644
--- a/ui/src/hooks/stores.ts
+++ b/ui/src/hooks/stores.ts
@@ -107,12 +107,21 @@ export interface RTCState {
setRpcDataChannel: (channel: RTCDataChannel) => void;
rpcDataChannel: RTCDataChannel | null;
+ hidRpcDisabled: boolean;
+ setHidRpcDisabled: (disabled: boolean) => void;
+
rpcHidProtocolVersion: number | null;
- setRpcHidProtocolVersion: (version: number) => void;
+ setRpcHidProtocolVersion: (version: number | null) => void;
rpcHidChannel: RTCDataChannel | null;
setRpcHidChannel: (channel: RTCDataChannel) => void;
+ rpcHidUnreliableChannel: RTCDataChannel | null;
+ setRpcHidUnreliableChannel: (channel: RTCDataChannel) => void;
+
+ rpcHidUnreliableNonOrderedChannel: RTCDataChannel | null;
+ setRpcHidUnreliableNonOrderedChannel: (channel: RTCDataChannel) => void;
+
peerConnectionState: RTCPeerConnectionState | null;
setPeerConnectionState: (state: RTCPeerConnectionState) => void;
@@ -169,12 +178,21 @@ export const useRTCStore = create
(set => ({
rpcDataChannel: null,
setRpcDataChannel: (channel: RTCDataChannel) => set({ rpcDataChannel: channel }),
+ hidRpcDisabled: false,
+ setHidRpcDisabled: (disabled: boolean) => set({ hidRpcDisabled: disabled }),
+
rpcHidProtocolVersion: null,
- setRpcHidProtocolVersion: (version: number) => set({ rpcHidProtocolVersion: version }),
+ setRpcHidProtocolVersion: (version: number | null) => set({ rpcHidProtocolVersion: version }),
rpcHidChannel: null,
setRpcHidChannel: (channel: RTCDataChannel) => set({ rpcHidChannel: channel }),
+ rpcHidUnreliableChannel: null,
+ setRpcHidUnreliableChannel: (channel: RTCDataChannel) => set({ rpcHidUnreliableChannel: channel }),
+
+ rpcHidUnreliableNonOrderedChannel: null,
+ setRpcHidUnreliableNonOrderedChannel: (channel: RTCDataChannel) => set({ rpcHidUnreliableNonOrderedChannel: channel }),
+
transceiver: null,
setTransceiver: (transceiver: RTCRtpTransceiver) => set({ transceiver }),
@@ -494,7 +512,7 @@ export interface HidState {
isVirtualKeyboardEnabled: boolean;
setVirtualKeyboardEnabled: (enabled: boolean) => void;
- isPasteModeEnabled: boolean;
+ isPasteInProgress: boolean;
setPasteModeEnabled: (enabled: boolean) => void;
usbState: USBStates;
@@ -511,8 +529,8 @@ export const useHidStore = create(set => ({
isVirtualKeyboardEnabled: false,
setVirtualKeyboardEnabled: (enabled: boolean): void => set({ isVirtualKeyboardEnabled: enabled }),
- isPasteModeEnabled: false,
- setPasteModeEnabled: (enabled: boolean): void => set({ isPasteModeEnabled: enabled }),
+ isPasteInProgress: false,
+ setPasteModeEnabled: (enabled: boolean): void => set({ isPasteInProgress: enabled }),
// Add these new properties for USB state
usbState: "not attached",
diff --git a/ui/src/hooks/useHidRpc.ts b/ui/src/hooks/useHidRpc.ts
index ea0c7112..aeb1c4fa 100644
--- a/ui/src/hooks/useHidRpc.ts
+++ b/ui/src/hooks/useHidRpc.ts
@@ -3,9 +3,13 @@ import { useCallback, useEffect, useMemo } from "react";
import { useRTCStore } from "@/hooks/stores";
import {
+ CancelKeyboardMacroReportMessage,
HID_RPC_VERSION,
HandshakeMessage,
+ KeyboardMacroStep,
+ KeyboardMacroReportMessage,
KeyboardReportMessage,
+ KeypressKeepAliveMessage,
KeypressReportMessage,
MouseReportMessage,
PointerReportMessage,
@@ -13,38 +17,97 @@ import {
unmarshalHidRpcMessage,
} from "./hidRpc";
+const KEEPALIVE_MESSAGE = new KeypressKeepAliveMessage();
+
+interface sendMessageParams {
+ ignoreHandshakeState?: boolean;
+ useUnreliableChannel?: boolean;
+ requireOrdered?: boolean;
+}
+
export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
- const { rpcHidChannel, setRpcHidProtocolVersion, rpcHidProtocolVersion } = useRTCStore();
+ const {
+ rpcHidChannel,
+ rpcHidUnreliableChannel,
+ rpcHidUnreliableNonOrderedChannel,
+ setRpcHidProtocolVersion,
+ rpcHidProtocolVersion, hidRpcDisabled,
+ } = useRTCStore();
+
const rpcHidReady = useMemo(() => {
+ if (hidRpcDisabled) return false;
return rpcHidChannel?.readyState === "open" && rpcHidProtocolVersion !== null;
- }, [rpcHidChannel, rpcHidProtocolVersion]);
+ }, [rpcHidChannel, rpcHidProtocolVersion, hidRpcDisabled]);
+
+ const rpcHidUnreliableReady = useMemo(() => {
+ return (
+ rpcHidUnreliableChannel?.readyState === "open" && rpcHidProtocolVersion !== null
+ );
+ }, [rpcHidProtocolVersion, rpcHidUnreliableChannel?.readyState]);
+
+ const rpcHidUnreliableNonOrderedReady = useMemo(() => {
+ return (
+ rpcHidUnreliableNonOrderedChannel?.readyState === "open" &&
+ rpcHidProtocolVersion !== null
+ );
+ }, [rpcHidProtocolVersion, rpcHidUnreliableNonOrderedChannel?.readyState]);
const rpcHidStatus = useMemo(() => {
+ if (hidRpcDisabled) return "disabled";
+
if (!rpcHidChannel) return "N/A";
if (rpcHidChannel.readyState !== "open") return rpcHidChannel.readyState;
if (!rpcHidProtocolVersion) return "handshaking";
- return `ready (v${rpcHidProtocolVersion})`;
- }, [rpcHidChannel, rpcHidProtocolVersion]);
+ return `ready (v${rpcHidProtocolVersion}${rpcHidUnreliableReady ? "+u" : ""})`;
+ }, [rpcHidChannel, rpcHidProtocolVersion, rpcHidUnreliableReady, hidRpcDisabled]);
- const sendMessage = useCallback((message: RpcMessage, ignoreHandshakeState = false) => {
+ const sendMessage = useCallback(
+ (
+ message: RpcMessage,
+ {
+ ignoreHandshakeState,
+ useUnreliableChannel,
+ requireOrdered = true,
+ }: sendMessageParams = {},
+ ) => {
+ if (hidRpcDisabled) return;
if (rpcHidChannel?.readyState !== "open") return;
- if (!rpcHidReady && !ignoreHandshakeState) return;
+ if (!rpcHidReady && !ignoreHandshakeState) return;
- let data: Uint8Array | undefined;
- try {
- data = message.marshal();
- } catch (e) {
- console.error("Failed to send HID RPC message", e);
- }
- if (!data) return;
+ let data: Uint8Array | undefined;
+ try {
+ data = message.marshal();
+ } catch (e) {
+ console.error("Failed to send HID RPC message", e);
+ }
+ if (!data) return;
- rpcHidChannel?.send(data as unknown as ArrayBuffer);
- }, [rpcHidChannel, rpcHidReady]);
+ if (useUnreliableChannel) {
+ if (requireOrdered && rpcHidUnreliableReady) {
+ rpcHidUnreliableChannel?.send(data as unknown as ArrayBuffer);
+ } else if (!requireOrdered && rpcHidUnreliableNonOrderedReady) {
+ rpcHidUnreliableNonOrderedChannel?.send(data as unknown as ArrayBuffer);
+ }
+ return;
+ }
+
+ rpcHidChannel?.send(data as unknown as ArrayBuffer);
+ },
+ [
+ rpcHidChannel,
+ rpcHidUnreliableChannel,
+ hidRpcDisabled, rpcHidUnreliableNonOrderedChannel,
+ rpcHidReady,
+ rpcHidUnreliableReady,
+ rpcHidUnreliableNonOrderedReady,
+ ],
+ );
const reportKeyboardEvent = useCallback(
(keys: number[], modifier: number) => {
sendMessage(new KeyboardReportMessage(keys, modifier));
- }, [sendMessage],
+ },
+ [sendMessage],
);
const reportKeypressEvent = useCallback(
@@ -56,7 +119,9 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
const reportAbsMouseEvent = useCallback(
(x: number, y: number, buttons: number) => {
- sendMessage(new PointerReportMessage(x, y, buttons));
+ sendMessage(new PointerReportMessage(x, y, buttons), {
+ useUnreliableChannel: true,
+ });
},
[sendMessage],
);
@@ -68,32 +133,57 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
[sendMessage],
);
+ const reportKeyboardMacroEvent = useCallback(
+ (steps: KeyboardMacroStep[]) => {
+ sendMessage(new KeyboardMacroReportMessage(false, steps.length, steps));
+ },
+ [sendMessage],
+ );
+
+ const cancelOngoingKeyboardMacro = useCallback(
+ () => {
+ sendMessage(new CancelKeyboardMacroReportMessage());
+ },
+ [sendMessage],
+ );
+
+ const reportKeypressKeepAlive = useCallback(() => {
+ sendMessage(KEEPALIVE_MESSAGE);
+ }, [sendMessage]);
+
const sendHandshake = useCallback(() => {
+ if (hidRpcDisabled) return;
if (rpcHidProtocolVersion) return;
if (!rpcHidChannel) return;
- sendMessage(new HandshakeMessage(HID_RPC_VERSION), true);
- }, [rpcHidChannel, rpcHidProtocolVersion, sendMessage]);
+ sendMessage(new HandshakeMessage(HID_RPC_VERSION), { ignoreHandshakeState: true });
+ }, [rpcHidChannel, rpcHidProtocolVersion, sendMessage, hidRpcDisabled]);
+
+ const handleHandshake = useCallback(
+ (message: HandshakeMessage) => {
+ if (hidRpcDisabled) return;
- const handleHandshake = useCallback((message: HandshakeMessage) => {
if (!message.version) {
- console.error("Received handshake message without version", message);
- return;
- }
+ console.error("Received handshake message without version", message);
+ return;
+ }
- if (message.version > HID_RPC_VERSION) {
- // we assume that the UI is always using the latest version of the HID RPC protocol
- // so we can't support this
- // TODO: use capabilities to determine rather than version number
- console.error("Server is using a newer HID RPC version than the client", message);
- return;
- }
+ if (message.version > HID_RPC_VERSION) {
+ // we assume that the UI is always using the latest version of the HID RPC protocol
+ // so we can't support this
+ // TODO: use capabilities to determine rather than version number
+ console.error("Server is using a newer HID RPC version than the client", message);
+ return;
+ }
- setRpcHidProtocolVersion(message.version);
- }, [setRpcHidProtocolVersion]);
+ setRpcHidProtocolVersion(message.version);
+ },
+ [setRpcHidProtocolVersion, hidRpcDisabled],
+ );
useEffect(() => {
if (!rpcHidChannel) return;
+ if (hidRpcDisabled) return;
// send handshake message
sendHandshake();
@@ -123,26 +213,42 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
onHidRpcMessage?.(message);
};
+ const openHandler = () => {
+ console.info("HID RPC channel opened");
+ sendHandshake();
+ };
+
+ const closeHandler = () => {
+ console.info("HID RPC channel closed");
+ setRpcHidProtocolVersion(null);
+ };
+
rpcHidChannel.addEventListener("message", messageHandler);
+ rpcHidChannel.addEventListener("close", closeHandler);
+ rpcHidChannel.addEventListener("open", openHandler);
return () => {
rpcHidChannel.removeEventListener("message", messageHandler);
+ rpcHidChannel.removeEventListener("close", closeHandler);
+ rpcHidChannel.removeEventListener("open", openHandler);
};
- },
- [
- rpcHidChannel,
- onHidRpcMessage,
- setRpcHidProtocolVersion,
- sendHandshake,
- handleHandshake,
- ],
- );
+ }, [
+ rpcHidChannel,
+ onHidRpcMessage,
+ setRpcHidProtocolVersion,
+ sendHandshake,
+ handleHandshake,
+ hidRpcDisabled,
+ ]);
return {
reportKeyboardEvent,
reportKeypressEvent,
reportAbsMouseEvent,
reportRelMouseEvent,
+ reportKeyboardMacroEvent,
+ cancelOngoingKeyboardMacro,
+ reportKeypressKeepAlive,
rpcHidProtocolVersion,
rpcHidReady,
rpcHidStatus,
diff --git a/ui/src/hooks/useJsonRpc.ts b/ui/src/hooks/useJsonRpc.ts
index b4fcc8ef..5c52d59c 100644
--- a/ui/src/hooks/useJsonRpc.ts
+++ b/ui/src/hooks/useJsonRpc.ts
@@ -29,6 +29,8 @@ export interface JsonRpcErrorResponse {
export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export const RpcMethodNotFound = -32601;
+
const callbackStore = new Map void>();
let requestCounter = 0;
diff --git a/ui/src/hooks/useKeyboard.ts b/ui/src/hooks/useKeyboard.ts
index 787df9a9..8d101b3b 100644
--- a/ui/src/hooks/useKeyboard.ts
+++ b/ui/src/hooks/useKeyboard.ts
@@ -1,15 +1,51 @@
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
-import { hidErrorRollOver, hidKeyBufferSize, KeysDownState, useHidStore, useRTCStore } from "@/hooks/stores";
-import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
+import {
+ KeyboardLedStateMessage,
+ KeyboardMacroStateMessage,
+ KeyboardMacroStep,
+ KeysDownStateMessage,
+} from "@/hooks/hidRpc";
+import {
+ hidErrorRollOver,
+ hidKeyBufferSize,
+ KeysDownState,
+ useHidStore,
+ useRTCStore,
+} from "@/hooks/stores";
import { useHidRpc } from "@/hooks/useHidRpc";
-import { KeyboardLedStateMessage, KeysDownStateMessage } from "@/hooks/hidRpc";
+import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
import { hidKeyToModifierMask, keys, modifiers } from "@/keyboardMappings";
+const MACRO_RESET_KEYBOARD_STATE = {
+ keys: new Array(hidKeyBufferSize).fill(0),
+ modifier: 0,
+ delay: 0,
+};
+
+export interface MacroStep {
+ keys: string[] | null;
+ modifiers: string[] | null;
+ delay: number;
+}
+
+export type MacroSteps = MacroStep[];
+
+const sleep = (ms: number): Promise => new Promise(resolve => setTimeout(resolve, ms));
+
export default function useKeyboard() {
const { send } = useJsonRpc();
const { rpcDataChannel } = useRTCStore();
- const { keysDownState, setKeysDownState, setKeyboardLedState } = useHidStore();
+ const { keysDownState, setKeysDownState, setKeyboardLedState, setPasteModeEnabled } =
+ useHidStore();
+
+ const abortController = useRef(null);
+ const setAbortController = useCallback((ac: AbortController | null) => {
+ abortController.current = ac;
+ }, []);
+
+ // Keepalive timer management
+ const keepAliveTimerRef = useRef(null);
// INTRODUCTION: The earlier version of the JetKVM device shipped with all keyboard state
// being tracked on the browser/client-side. When adding the keyPressReport API to the
@@ -17,17 +53,19 @@ export default function useKeyboard() {
// is running on the cloud against a device that has not been updated yet and thus does not
// support the keyPressReport API. In that case, we need to handle the key presses locally
// and send the full state to the device, so it can behave like a real USB HID keyboard.
- // This flag indicates whether the keyPressReport API is available on the device which is
- // dynamically set when the device responds to the first key press event or reports its
- // keysDownState when queried since the keyPressReport was introduced together with the
+ // This flag indicates whether the keyPressReport API is available on the device which is
+ // dynamically set when the device responds to the first key press event or reports its // keysDownState when queried since the keyPressReport was introduced together with the
// getKeysDownState API.
// HidRPC is a binary format for exchanging keyboard and mouse events
const {
reportKeyboardEvent: sendKeyboardEventHidRpc,
reportKeypressEvent: sendKeypressEventHidRpc,
+ reportKeyboardMacroEvent: sendKeyboardMacroEventHidRpc,
+ cancelOngoingKeyboardMacro: cancelOngoingKeyboardMacroHidRpc,
+ reportKeypressKeepAlive: sendKeypressKeepAliveHidRpc,
rpcHidReady,
- } = useHidRpc((message) => {
+ } = useHidRpc(message => {
switch (message.constructor) {
case KeysDownStateMessage:
setKeysDownState((message as KeysDownStateMessage).keysDownState);
@@ -35,81 +73,80 @@ export default function useKeyboard() {
case KeyboardLedStateMessage:
setKeyboardLedState((message as KeyboardLedStateMessage).keyboardLedState);
break;
+ case KeyboardMacroStateMessage:
+ if (!(message as KeyboardMacroStateMessage).isPaste) break;
+ setPasteModeEnabled((message as KeyboardMacroStateMessage).state);
+ break;
default:
break;
}
});
- // sendKeyboardEvent is used to send the full keyboard state to the device for macro handling
- // and resetting keyboard state. It sends the keys currently pressed and the modifier state.
- // The device will respond with the keysDownState if it supports the keyPressReport API
- // or just accept the state if it does not support (returning no result)
- const sendKeyboardEvent = useCallback(
- async (state: KeysDownState) => {
- if (rpcDataChannel?.readyState !== "open" && !rpcHidReady) return;
-
- console.debug(`Send keyboardReport keys: ${state.keys}, modifier: ${state.modifier}`);
-
- if (rpcHidReady) {
- console.debug("Sending keyboard report via HidRPC");
- sendKeyboardEventHidRpc(state.keys, state.modifier);
- return;
- }
-
- send("keyboardReport", { keys: state.keys, modifier: state.modifier }, (resp: JsonRpcResponse) => {
+ const handleLegacyKeyboardReport = useCallback(
+ async (keys: number[], modifier: number) => {
+ send("keyboardReport", { keys, modifier }, (resp: JsonRpcResponse) => {
if ("error" in resp) {
- console.error(`Failed to send keyboard report ${state}`, resp.error);
+ console.error(`Failed to send keyboard report ${keys} ${modifier}`, resp.error);
}
+
+ // On older backends, we need to set the keysDownState manually since without the hidRpc API, the state doesn't trickle down from the backend
+ setKeysDownState({ modifier, keys });
});
},
- [
- rpcDataChannel?.readyState,
- rpcHidReady,
- send,
- sendKeyboardEventHidRpc,
- ],
+ [send, setKeysDownState],
);
- // resetKeyboardState is used to reset the keyboard state to no keys pressed and no modifiers.
- // This is useful for macros and when the browser loses focus to ensure that the keyboard state
- // is clean.
- const resetKeyboardState = useCallback(
- async () => {
- // Reset the keys buffer to zeros and the modifier state to zero
- keysDownState.keys.length = hidKeyBufferSize;
- keysDownState.keys.fill(0);
- keysDownState.modifier = 0;
- sendKeyboardEvent(keysDownState);
- }, [keysDownState, sendKeyboardEvent]);
+ const sendKeystrokeLegacy = useCallback(async (keys: number[], modifier: number, ac?: AbortController) => {
+ return await new Promise((resolve, reject) => {
+ const abortListener = () => {
+ reject(new Error("Keyboard report aborted"));
+ };
- // executeMacro is used to execute a macro consisting of multiple steps.
- // Each step can have multiple keys, multiple modifiers and a delay.
- // The keys and modifiers are pressed together and held for the delay duration.
- // After the delay, the keys and modifiers are released and the next step is executed.
- // If a step has no keys or modifiers, it is treated as a delay-only step.
- // A small pause is added between steps to ensure that the device can process the events.
- const executeMacro = async (steps: { keys: string[] | null; modifiers: string[] | null; delay: number }[]) => {
- for (const [index, step] of steps.entries()) {
- const keyValues = (step.keys || []).map(key => keys[key]).filter(Boolean);
- const modifierMask: number = (step.modifiers || []).map(mod => modifiers[mod]).reduce((acc, val) => acc + val, 0);
+ ac?.signal?.addEventListener("abort", abortListener);
- // If the step has keys and/or modifiers, press them and hold for the delay
- if (keyValues.length > 0 || modifierMask > 0) {
- sendKeyboardEvent({ keys: keyValues, modifier: modifierMask });
- await new Promise(resolve => setTimeout(resolve, step.delay || 50));
+ send(
+ "keyboardReport",
+ { keys, modifier },
+ params => {
+ if ("error" in params) return reject(params.error);
+ resolve();
+ },
+ );
+ });
+ }, [send]);
- resetKeyboardState();
- } else {
- // This is a delay-only step, just wait for the delay amount
- await new Promise(resolve => setTimeout(resolve, step.delay || 50));
- }
+ const KEEPALIVE_INTERVAL = 50;
- // Add a small pause between steps if not the last step
- if (index < steps.length - 1) {
- await new Promise(resolve => setTimeout(resolve, 10));
- }
+ const cancelKeepAlive = useCallback(() => {
+ if (keepAliveTimerRef.current) {
+ clearInterval(keepAliveTimerRef.current);
+ keepAliveTimerRef.current = null;
}
- };
+ }, []);
+
+ const scheduleKeepAlive = useCallback(() => {
+ // Clears existing keepalive timer
+ cancelKeepAlive();
+
+ keepAliveTimerRef.current = setInterval(() => {
+ sendKeypressKeepAliveHidRpc();
+ }, KEEPALIVE_INTERVAL);
+ }, [cancelKeepAlive, sendKeypressKeepAliveHidRpc]);
+
+ // resetKeyboardState is used to reset the keyboard state to no keys pressed and no modifiers.
+ // This is useful for macros, in case of client-side rollover, and when the browser loses focus
+ const resetKeyboardState = useCallback(async () => {
+ // Cancel keepalive since we're resetting the keyboard state
+ cancelKeepAlive();
+ // Reset the keys buffer to zeros and the modifier state to zero
+ const { keys, modifier } = MACRO_RESET_KEYBOARD_STATE;
+ if (rpcHidReady) {
+ sendKeyboardEventHidRpc(keys, modifier);
+ } else {
+ // Older backends don't support the hidRpc API, so we send the full reset state
+ handleLegacyKeyboardReport(keys, modifier);
+ }
+ }, [rpcHidReady, sendKeyboardEventHidRpc, handleLegacyKeyboardReport, cancelKeepAlive]);
// handleKeyPress is used to handle a key press or release event.
// This function handle both key press and key release events.
@@ -117,6 +154,20 @@ export default function useKeyboard() {
// If the keyPressReport API is not available, it simulates the device-side key
// handling for legacy devices and updates the keysDownState accordingly.
// It then sends the full keyboard state to the device.
+
+ const sendKeypress = useCallback(
+ (key: number, press: boolean) => {
+ cancelKeepAlive();
+
+ sendKeypressEventHidRpc(key, press);
+
+ if (press) {
+ scheduleKeepAlive();
+ }
+ },
+ [sendKeypressEventHidRpc, scheduleKeepAlive, cancelKeepAlive],
+ );
+
const handleKeyPress = useCallback(
async (key: number, press: boolean) => {
if (rpcDataChannel?.readyState !== "open" && !rpcHidReady) return;
@@ -129,11 +180,18 @@ export default function useKeyboard() {
// Older device version doesn't support this API, so we will switch to local key handling
// In that case we will switch to local key handling and update the keysDownState
// in client/browser-side code using simulateDeviceSideKeyHandlingForLegacyDevices.
- sendKeypressEventHidRpc(key, press);
+ sendKeypress(key, press);
} else {
- // if the keyPress api is not available, we need to handle the key locally
- const downState = simulateDeviceSideKeyHandlingForLegacyDevices(keysDownState, key, press);
- sendKeyboardEvent(downState); // then we send the full state
+ // Older backends don't support the hidRpc API, so we need:
+ // 1. Calculate the state
+ // 2. Send the newly calculated state to the device
+ const downState = simulateDeviceSideKeyHandlingForLegacyDevices(
+ keysDownState,
+ key,
+ press,
+ );
+
+ handleLegacyKeyboardReport(downState.keys, downState.modifier);
// if we just sent ErrorRollOver, reset to empty state
if (downState.keys[0] === hidErrorRollOver) {
@@ -142,17 +200,21 @@ export default function useKeyboard() {
}
},
[
+ rpcDataChannel?.readyState,
rpcHidReady,
keysDownState,
+ handleLegacyKeyboardReport,
resetKeyboardState,
- rpcDataChannel?.readyState,
- sendKeyboardEvent,
- sendKeypressEventHidRpc,
+ sendKeypress,
],
);
// IMPORTANT: See the keyPressReportApiAvailable comment above for the reason this exists
- function simulateDeviceSideKeyHandlingForLegacyDevices(state: KeysDownState, key: number, press: boolean): KeysDownState {
+ function simulateDeviceSideKeyHandlingForLegacyDevices(
+ state: KeysDownState,
+ key: number,
+ press: boolean,
+ ): KeysDownState {
// IMPORTANT: This code parallels the logic in the kernel's hid-gadget driver
// for handling key presses and releases. It ensures that the USB gadget
// behaves similarly to a real USB HID keyboard. This logic is paralleled
@@ -164,7 +226,7 @@ export default function useKeyboard() {
if (modifierMask !== 0) {
// If the key is a modifier key, we update the keyboardModifier state
// by setting or clearing the corresponding bit in the modifier byte.
- // This allows us to track the state of dynamic modifier keys like
+ // This allows us to track the state of dynamic modifier keys like
// Shift, Control, Alt, and Super.
if (press) {
modifiers |= modifierMask;
@@ -181,7 +243,7 @@ export default function useKeyboard() {
// and if we find a zero byte, we can place the key there (if press is true)
if (keys[i] === key || keys[i] === 0) {
if (press) {
- keys[i] = key // overwrites the zero byte or the same key if already pressed
+ keys[i] = key; // overwrites the zero byte or the same key if already pressed
} else {
// we are releasing the key, remove it from the buffer
if (keys[i] !== 0) {
@@ -203,12 +265,113 @@ export default function useKeyboard() {
keys.fill(hidErrorRollOver);
} else {
// If we are releasing a key, and we didn't find it in a slot, who cares?
- console.debug(`key ${key} not found in buffer, nothing to release`)
+ console.debug(`key ${key} not found in buffer, nothing to release`);
}
}
}
return { modifier: modifiers, keys };
}
- return { handleKeyPress, resetKeyboardState, executeMacro };
+ // Cleanup function to cancel keepalive timer
+ const cleanup = useCallback(() => {
+ cancelKeepAlive();
+ }, [cancelKeepAlive]);
+
+
+ // executeMacro is used to execute a macro consisting of multiple steps.
+ // Each step can have multiple keys, multiple modifiers and a delay.
+ // The keys and modifiers are pressed together and held for the delay duration.
+ // After the delay, the keys and modifiers are released and the next step is executed.
+ // If a step has no keys or modifiers, it is treated as a delay-only step.
+ // A small pause is added between steps to ensure that the device can process the events.
+ const executeMacroRemote = useCallback(async (
+ steps: MacroSteps,
+ ) => {
+ const macro: KeyboardMacroStep[] = [];
+
+ for (const [_, step] of steps.entries()) {
+ const keyValues = (step.keys || []).map(key => keys[key]).filter(Boolean);
+ const modifierMask: number = (step.modifiers || [])
+
+ .map(mod => modifiers[mod])
+
+ .reduce((acc, val) => acc + val, 0);
+
+ // If the step has keys and/or modifiers, press them and hold for the delay
+ if (keyValues.length > 0 || modifierMask > 0) {
+ macro.push({ keys: keyValues, modifier: modifierMask, delay: 20 });
+ macro.push({ ...MACRO_RESET_KEYBOARD_STATE, delay: step.delay || 100 });
+ }
+ }
+
+ sendKeyboardMacroEventHidRpc(macro);
+ }, [sendKeyboardMacroEventHidRpc]);
+ const executeMacroClientSide = useCallback(async (steps: MacroSteps) => {
+ const promises: (() => Promise)[] = [];
+
+ const ac = new AbortController();
+ setAbortController(ac);
+
+ for (const [_, step] of steps.entries()) {
+ const keyValues = (step.keys || []).map(key => keys[key]).filter(Boolean);
+ const modifierMask: number = (step.modifiers || [])
+ .map(mod => modifiers[mod])
+ .reduce((acc, val) => acc + val, 0);
+
+ // If the step has keys and/or modifiers, press them and hold for the delay
+ if (keyValues.length > 0 || modifierMask > 0) {
+ promises.push(() => sendKeystrokeLegacy(keyValues, modifierMask, ac));
+ promises.push(() => resetKeyboardState());
+ promises.push(() => sleep(step.delay || 100));
+ }
+ }
+
+ const runAll = async () => {
+ for (const promise of promises) {
+ // Check if we've been aborted before executing each promise
+ if (ac.signal.aborted) {
+ throw new Error("Macro execution aborted");
+ }
+ await promise();
+ }
+ }
+
+ return await new Promise((resolve, reject) => {
+ // Set up abort listener
+ const abortListener = () => {
+ reject(new Error("Macro execution aborted"));
+ };
+
+ ac.signal.addEventListener("abort", abortListener);
+
+ runAll()
+ .then(() => {
+ ac.signal.removeEventListener("abort", abortListener);
+ resolve();
+ })
+ .catch((error) => {
+ ac.signal.removeEventListener("abort", abortListener);
+ reject(error);
+ });
+ });
+ }, [sendKeystrokeLegacy, resetKeyboardState, setAbortController]);
+ const executeMacro = useCallback(async (steps: MacroSteps) => {
+ if (rpcHidReady) {
+ return executeMacroRemote(steps);
+ }
+ return executeMacroClientSide(steps);
+ }, [rpcHidReady, executeMacroRemote, executeMacroClientSide]);
+
+ const cancelExecuteMacro = useCallback(async () => {
+ if (abortController.current) {
+ abortController.current.abort();
+ }
+ if (!rpcHidReady) return;
+ // older versions don't support this API,
+ // and all paste actions are pure-frontend,
+ // we don't need to cancel it actually
+ cancelOngoingKeyboardMacroHidRpc();
+ }, [rpcHidReady, cancelOngoingKeyboardMacroHidRpc, abortController]);
+
+ return { handleKeyPress, resetKeyboardState, executeMacro, cleanup, cancelExecuteMacro };
}
diff --git a/ui/src/hooks/useVersion.tsx b/ui/src/hooks/useVersion.tsx
new file mode 100644
index 00000000..7341dacb
--- /dev/null
+++ b/ui/src/hooks/useVersion.tsx
@@ -0,0 +1,79 @@
+import { useCallback } from "react";
+
+import { useDeviceStore } from "@/hooks/stores";
+import { type JsonRpcResponse, RpcMethodNotFound, useJsonRpc } from "@/hooks/useJsonRpc";
+import notifications from "@/notifications";
+
+export interface VersionInfo {
+ appVersion: string;
+ systemVersion: string;
+}
+
+export interface SystemVersionInfo {
+ local: VersionInfo;
+ remote?: VersionInfo;
+ systemUpdateAvailable: boolean;
+ appUpdateAvailable: boolean;
+ error?: string;
+}
+
+export function useVersion() {
+ const {
+ appVersion,
+ systemVersion,
+ setAppVersion,
+ setSystemVersion,
+ } = useDeviceStore();
+ const { send } = useJsonRpc();
+ const getVersionInfo = useCallback(() => {
+ return new Promise((resolve, reject) => {
+ send("getUpdateStatus", {}, (resp: JsonRpcResponse) => {
+ if ("error" in resp) {
+ notifications.error(`Failed to check for updates: ${resp.error}`);
+ reject(new Error("Failed to check for updates"));
+ } else {
+ const result = resp.result as SystemVersionInfo;
+ setAppVersion(result.local.appVersion);
+ setSystemVersion(result.local.systemVersion);
+
+ if (result.error) {
+ notifications.error(`Failed to check for updates: ${result.error}`);
+ reject(new Error("Failed to check for updates"));
+ } else {
+ resolve(result);
+ }
+ }
+ });
+ });
+ }, [send, setAppVersion, setSystemVersion]);
+
+ const getLocalVersion = useCallback(() => {
+ return new Promise((resolve, reject) => {
+ send("getLocalVersion", {}, (resp: JsonRpcResponse) => {
+ if ("error" in resp) {
+ console.log(resp.error)
+ if (resp.error.code === RpcMethodNotFound) {
+ console.warn("Failed to get device version, using legacy version");
+ return getVersionInfo().then(result => resolve(result.local)).catch(reject);
+ }
+ console.error("Failed to get device version N", resp.error);
+ notifications.error(`Failed to get device version: ${resp.error}`);
+ reject(new Error("Failed to get device version"));
+ } else {
+ const result = resp.result as VersionInfo;
+
+ setAppVersion(result.appVersion);
+ setSystemVersion(result.systemVersion);
+ resolve(result);
+ }
+ });
+ });
+ }, [send, setAppVersion, setSystemVersion, getVersionInfo]);
+
+ return {
+ getVersionInfo,
+ getLocalVersion,
+ appVersion,
+ systemVersion,
+ };
+}
\ No newline at end of file
diff --git a/ui/src/index.css b/ui/src/index.css
index ae23db2b..6eaae1f7 100644
--- a/ui/src/index.css
+++ b/ui/src/index.css
@@ -239,7 +239,7 @@ video::-webkit-media-controls {
}
.simple-keyboard-arrows .hg-button {
- @apply flex w-[50px] grow-0 items-center justify-center;
+ @apply flex w-[50px] items-center justify-center;
}
.controlArrows {
@@ -264,7 +264,7 @@ video::-webkit-media-controls {
}
.simple-keyboard-control .hg-button {
- @apply flex w-[50px] grow-0 items-center justify-center;
+ @apply flex w-[50px] items-center justify-center;
}
.numPad {
@@ -332,7 +332,7 @@ video::-webkit-media-controls {
.keyboard-detached .simple-keyboard.hg-theme-default div.hg-button {
text-wrap: auto;
- text-align: center;
+ text-align: center;
min-width: 6ch;
}
.keyboard-detached .simple-keyboard.hg-theme-default .hg-button span {
diff --git a/ui/src/routes/devices.$id.settings.general.update.tsx b/ui/src/routes/devices.$id.settings.general.update.tsx
index 80ba0f78..38c15412 100644
--- a/ui/src/routes/devices.$id.settings.general.update.tsx
+++ b/ui/src/routes/devices.$id.settings.general.update.tsx
@@ -3,12 +3,12 @@ import { useCallback, useEffect, useRef, useState } from "react";
import { CheckCircleIcon } from "@heroicons/react/20/solid";
import Card from "@/components/Card";
-import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
+import { useJsonRpc } from "@/hooks/useJsonRpc";
import { Button } from "@components/Button";
-import { UpdateState, useDeviceStore, useUpdateStore } from "@/hooks/stores";
-import notifications from "@/notifications";
+import { UpdateState, useUpdateStore } from "@/hooks/stores";
import LoadingSpinner from "@/components/LoadingSpinner";
import { useDeviceUiNavigation } from "@/hooks/useAppNavigation";
+import { SystemVersionInfo, useVersion } from "@/hooks/useVersion";
export default function SettingsGeneralUpdateRoute() {
const navigate = useNavigate();
@@ -41,13 +41,7 @@ export default function SettingsGeneralUpdateRoute() {
return