yjz-web-sdk 1.0.10 → 1.0.11-beta.10

package/lib/components/RemotePlayer/index.vue.d.ts

@@ -1,74 +1,2 @@
-import type { Dimension } from "./type";
-interface Props {
-    streamAngle?: number;
-    videoAngle?: number;
-    cursorType?: number;
-    cloudDeviceSize?: Dimension;
-    disabled?: boolean;
-    bgColor?: string;
-    isGroup?: boolean;
-}
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
-    streamAngle: number;
-    videoAngle: number;
-    cursorType: number;
-    cloudDeviceSize: () => {
-        width: number;
-        height: number;
-    };
-    disabled: boolean;
-    bgColor: string;
-    isGroup: boolean;
-}>>, {
-    startDecode: (arrayBuffer: ArrayBuffer) => void;
-    stopPlay: () => void;
-    remoteVideoElement: import("vue").Ref<HTMLCanvasElement, HTMLCanvasElement>;
-    startPlay: (track: MediaStreamTrack) => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    loadedSuccess: (...args: any[]) => void;
-    loadedFailure: (...args: any[]) => void;
-    channelEvent: (...args: any[]) => void;
-    groupControlEvent: (...args: any[]) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
-    streamAngle: number;
-    videoAngle: number;
-    cursorType: number;
-    cloudDeviceSize: () => {
-        width: number;
-        height: number;
-    };
-    disabled: boolean;
-    bgColor: string;
-    isGroup: boolean;
-}>>> & Readonly<{
-    onLoadedSuccess?: (...args: any[]) => any;
-    onLoadedFailure?: (...args: any[]) => any;
-    onChannelEvent?: (...args: any[]) => any;
-    onGroupControlEvent?: (...args: any[]) => any;
-}>, {
-    cloudDeviceSize: Dimension;
-    streamAngle: number;
-    videoAngle: number;
-    isGroup: boolean;
-    cursorType: number;
-    disabled: boolean;
-    bgColor: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: any;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/lib/composables/useCursorStyle.d.ts

@@ -1,2 +1,2 @@
 import type { Ref } from 'vue';
-export default function useCursorStyle(cursorType: Ref<number>): import("vue").ComputedRef<"circle-cursor" | "triangle-cursor" | "default-cursor">;
+export default function useCursorStyle(cursorType: Ref<number>): any;

package/lib/composables/useKeyboardControl.d.ts

@@ -1,6 +1,10 @@
 import { ChannelDataType } from "../core/data/WebrtcDataType";
 import { type Ref } from "vue";
-export default function useKeyboardControl(disabled: Ref<boolean>, emit: (event: 'channelEvent', payload: ChannelDataType, data: any) => void): {
+export default function useKeyboardControl(imeInput: Ref<HTMLTextAreaElement | null>, disabled: Ref<boolean>, emit: (event: 'channelEvent', payload: ChannelDataType, data: any) => void): {
     startListening: () => void;
     stopListening: () => void;
+    onCompositionStart: (_e: CompositionEvent) => void;
+    onCompositionEnd: (e: CompositionEvent) => void;
+    onInput: (e: InputEvent) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
 };

package/lib/composables/useMouseTouchControl.d.ts

@@ -1,21 +1,22 @@
 import type { Ref } from 'vue';
 import { ChannelDataType } from "../core/data/WebrtcDataType";
-import type { Dimension } from "../components/RemotePlayer/type";
+import type { Dimension } from "../components/RemotePlayer/index.ts";
 interface MouseTouchControlOptions {
-    remoteVideoElement: Ref<HTMLCanvasElement | null>;
+    remoteVideoElement: Ref<HTMLVideoElement | null>;
     cloudDeviceSize: Ref<Dimension>;
     streamAngle: Ref<number>;
     videoAngle: Ref<number>;
     widthRadio: Ref<number>;
     isGroup: Ref<boolean>;
+    isMove: Ref<boolean>;
     emit: (event: 'channelEvent', payload: ChannelDataType, data: any) => void;
 }
 export default function useMouseTouchControl(options: MouseTouchControlOptions): {
-    isPointerDown: Ref<boolean, boolean>;
+    pointers: any;
     handleMouseDown: (event: PointerEvent) => void;
     handleMouseMove: (event: PointerEvent) => void;
-    handleMouseEnter: (event: PointerEvent) => void;
     handleMouseUp: (event: PointerEvent) => void;
+    handleMouseEnter: (event: PointerEvent) => void;
     handleMouseLeave: (event: PointerEvent) => void;
     handleWheel: (e: WheelEvent) => void;
 };

package/lib/composables/useRemoteVideo.d.ts

@@ -1,29 +1,12 @@
 import type { Ref } from 'vue';
-import { Dimension } from '../components/RemotePlayer/type';
-export default function useRemoteVideo(videoContainer: Ref<HTMLElement | null>, remoteVideoElement: Ref<HTMLCanvasElement | null>, audioElement: Ref<HTMLAudioElement | null>, videoAngle: Ref<number>, emit: (event: 'loadedSuccess' | 'loadedFailure', reason?: string) => void): {
-    videoSize: import("vue").ComputedRef<{
-        width: number;
-        height: number;
-    }>;
-    remoteVideo: Ref<{
-        width?: number;
-        height?: number;
-    }, Partial<Dimension> | {
-        width?: number;
-        height?: number;
-    }>;
-    dimensions: Ref<{
-        width: number;
-        height: number;
-    }, Dimension | {
-        width: number;
-        height: number;
-    }>;
-    widthRadio: Ref<number, number>;
-    heightRadio: Ref<number, number>;
-    screenStatus: Ref<boolean, boolean>;
+export default function useRemoteVideo(videoContainer: Ref<HTMLElement | null>, remoteVideoElement: Ref<HTMLVideoElement | null>, videoAngle: Ref<number>, emit: (event: 'loadedSuccess') => void): {
+    videoSize: any;
+    remoteVideo: any;
+    dimensions: any;
+    widthRadio: any;
+    heightRadio: any;
+    screenStatus: any;
     initVideoContainer: () => void;
-    startDecode: (arrayBuffer: ArrayBuffer) => void;
-    stopPlay: () => void;
     startPlay: (track: MediaStreamTrack) => void;
+    stopPlay: () => void;
 };

package/lib/composables/useResizeObserver.d.ts

@@ -1,3 +1,3 @@
 import type { Ref } from 'vue';
-import type { Dimension } from "../components/RemotePlayer/type";
+import type { Dimension } from "../components/RemotePlayer/index.ts";
 export default function useResizeObserver(target: Ref<HTMLElement | null>, dimension: Ref<Dimension>): void;

package/lib/core/WebRTCSdk.d.ts

@@ -15,11 +15,13 @@ export declare class WebRTCSdk extends EventEmitter {
     private connectCount;
     private MAX_COUNT;
     private timeout;
+    private reconnectTimer;
     constructor(options: WebRTCConfigOptions);
     initConfig(): Promise<void>;
     /** 开始连接 signal 服务 */
     startConnection(): void;
     private prepareConnection;
+    private scheduleReconnect;
     reconnect(): Promise<void>;
     initConnectConfig(initConfig?: boolean): void;
     initSignalingClient(): void;
@@ -53,4 +55,5 @@ export declare class WebRTCSdk extends EventEmitter {
     sendPong(): void;
     sendSignOut(): void;
     groupSendAction(type: ChannelDataType, data: any): void;
+    private clearReconnectTimer;
 }

package/lib/core/data/WebRtcError.d.ts

@@ -16,7 +16,8 @@ export declare enum FailCode {
     AUTH_FAILED = 10015,
     KICK_OUT_ERR = 10016,
     STATE_ERR = 10017,
-    OPTION_ERR = 10018
+    OPTION_ERR = 10018,
+    NO_OPTION_LONGTIME = 10019
 }
 export declare const FailInfoMap: Record<FailCode, {
     type: string;
@@ -52,6 +53,5 @@ export declare enum EmitType {
     cloudClipData = "cloudClipData",
     screenshot = "screenshot",
     reconnect = "reconnect",
-    groupError = "groupError",
-    arrayBuffer = "arrayBuffer"
+    groupError = "groupError"
 }

package/lib/core/data/WebrtcDataType.d.ts

@@ -11,8 +11,7 @@ export declare enum ChannelDataType {
     ActionCommandEvent = "ActionCommandEvent",
     ActionUpdateCloudStatus = "ActionUpdateCloudStatus",
     ActionGesture = "ActionGesture",
-    ActionTrack = "ActionTrack",
-    RequestKeyFrame = "RequestKeyFrame"
+    ActionTrack = "ActionTrack"
 }
 export declare enum ActionCommandEventValue {
     ENABLE = "ENABLE",
@@ -175,7 +174,6 @@ export declare class ChannelData {
     static clarity(data: any): ChannelData;
     static switchAudio(data: any): ChannelData;
     static changeSender(data: any): ChannelData;
-    static requestKeyFrame(data: any): ChannelData;
 }
 export interface RTCStatsReportExtended extends RTCStatsReport {
     get(id: string): RTCStats | undefined;
@@ -210,11 +208,3 @@ export interface ScreenShotData {
     roomId: string;
     base64: string;
 }
-export declare class BitReader {
-    private data;
-    private byteOffset;
-    private bitOffset;
-    constructor(data: Uint8Array);
-    readBits(count: number): number;
-    readUEG(): number;
-}

package/lib/core/groupctrl/SdkController.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'eventemitter3';
-import type { WebRTCConfigOptions } from '../rtc/WebRTCConfig';
+import type { WebRTCConfigOptions } from '../rtc/WebRTCConfig.ts';
 import { WebRTCSdk } from '../WebRTCSdk';
-import type { ChannelDataType } from '../data/WebrtcDataType';
+import type { ChannelDataType } from '../data/WebrtcDataType.ts';
 import type { ConnectorType } from '../data/MessageType';
 export declare class SdkController extends EventEmitter {
     private readonly sdk;

package/lib/core/rtc/WebRTCClient.d.ts

@@ -19,12 +19,19 @@ export declare class WebRTCClient extends EventEmitter {
     private maxLostRate;
     private lastSecondDecodedCount;
     private fileVideo?;
+    private videoTransceiver?;
+    private audioTransceiver?;
     private canvas?;
     private canvasStream;
     private rafId;
     private currentMedia;
     private fileImage?;
-    private isFirst;
+    private reConnectTimer;
+    private canPushStream;
+    private idleTimer;
+    private retryCount;
+    private readonly MAX_RETRY_PER_RECONNECT;
+    private lastIdleResetTime;
     constructor(config: WebRTCConfig);
     startPush(useBackCamera?: boolean): Promise<void>;
     handleOffer(offerSdp: string): void;
@@ -39,10 +46,10 @@ export declare class WebRTCClient extends EventEmitter {
     switchCamera(useBackCamera: boolean): Promise<void>;
     private getRotatedStream;
     private setVideoParams;
-    stopPush(): void;
+    stopPush(): Promise<void>;
     private resetPeerConnection;
+    private onConnected;
     private configDataChannel;
-    private handleVideoChannelMessage;
     private handleDataChannelMessage;
     private checkStats;
     private processStatsOptimized;
@@ -57,4 +64,7 @@ export declare class WebRTCClient extends EventEmitter {
     getFileImage(): HTMLImageElement;
     /** 停止推流并释放资源 */
     stopLocal(): void;
+    private resetIdleTimer;
+    /** 停止空闲计时器 */
+    private clearIdleTimer;
 }

package/lib/core/rtc/WebRTCConfig.d.ts

@@ -1,5 +1,5 @@
 import { ConnectorType } from '../data/MessageType';
-import { LogLevel } from "../util/Logger";
+import { LogLevel } from "../util/Logger.ts";
 export interface WebRTCConfigOptions {
     signalServerUrl: string;
     myId?: string;
@@ -33,6 +33,7 @@ export interface WebRTCConfigOptions {
     cacheTimeout?: number;
     enableLogger?: boolean;
     loggerLevel?: LogLevel;
+    operateTimeout?: number;
 }
 export declare class WebRTCConfig {
     signalServerUrl: string;
@@ -56,5 +57,6 @@ export declare class WebRTCConfig {
     turnKey: Array<string>;
     traceId: string;
     signAgain: boolean;
+    operateTimeout: number;
     constructor(options: WebRTCConfigOptions);
 }

package/lib/core/rtc/WebRtcNegotiate.d.ts

@@ -1,9 +1,9 @@
-import { type WebRtcError } from "../data/WebRtcError";
-import { WebRTCConfig } from "./WebRTCConfig";
+import { type WebRtcError } from "../data/WebRtcError.ts";
+import { WebRTCConfig } from "./WebRTCConfig.ts";
 export declare const setRemoteDescriptionWithHandleOffer: (peerConnection: RTCPeerConnection, sdp: string, sendAnswer?: (sdp: string) => void, onError?: (err: WebRtcError) => void) => void;
 export declare const createPeerConnection: (config: WebRTCConfig) => RTCPeerConnection;
 export declare const configPeerConnection: (peerConnection: RTCPeerConnection, onICEMessage: (candidate: string) => void, onTrack?: (track: MediaStreamTrack) => void, onConnectState?: (state: RTCIceConnectionState) => void, onError?: (error: WebRtcError) => void) => void;
-export declare const setRemoteDescriptionWithHandleAnswer: (peerConnection: RTCPeerConnection, sdp: string, onError?: (error: WebRtcError) => void) => void;
+export declare const setRemoteDescriptionWithHandleAnswer: (peerConnection: RTCPeerConnection, sdp: string, onSuccess?: () => void, onError?: (error: WebRtcError) => void) => void;
 export declare const createOffer: (peerConnection: RTCPeerConnection, sendOfferMessage: (sdp: string) => void) => Promise<void>;
 export declare const setLocalDescriptionWithCreateOffer: (peerConnection: RTCPeerConnection, offer: RTCSessionDescriptionInit, sendOfferMessage: (sdp: string) => void) => Promise<void>;
 export declare const addIceCandidate: (peerConnection: RTCPeerConnection, candidate: RTCIceCandidateInit, onError?: (error: WebRtcError) => void) => void;

package/lib/core/signal/SignalingClient.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
-import type { WebRTCConfig } from '../rtc/WebRTCConfig';
+import type { WebRTCConfig } from '../rtc/WebRTCConfig.ts';
 import { ConnectorType } from '../data/MessageType';
 export declare class SignalingClient extends EventEmitter {
     private config;

package/lib/core/util/KeyCodeUtil.d.ts

@@ -14,3 +14,9 @@ export interface KeyEventData {
  * @returns 包含 androidKeyCode 和 metaState 的对象
  */
 export declare const getKeyEventData: (event: KeyboardEvent) => KeyEventData;
+/**
+ * 判断当前按键是否属于功能键
+ * @param event - 浏览器 KeyboardEvent
+ * @returns true 表示是功能键
+ */
+export declare const isFunctionKey: (event: KeyboardEvent) => boolean;

package/lib/core/util/TurnTestUtil.d.ts

@@ -1,6 +1,6 @@
-import type { TurnSelectionResult, TurnServerConfig, TurnTestResult, TurnTestSummary } from '../data/TurnType';
-import type { WebRTCConfigOptions } from '../rtc/WebRTCConfig';
+import type { TurnSelectionResult, TurnServerConfig, TurnTestResult, TurnTestSummary } from '../data/TurnType.ts';
+import type { WebRTCConfigOptions } from '../rtc/WebRTCConfig.ts';
 export declare const testTurnServer: (turnConfig: TurnServerConfig, timeoutMs?: number) => Promise<TurnTestResult>;
-export declare const testMultipleTurnServers: (servers: string[], timeoutMs?: number) => Promise<TurnTestSummary>;
+export declare const testMultipleTurnServersFast: (servers: string[], timeoutMs?: number, concurrency?: number) => Promise<TurnTestSummary>;
 export declare const areTurnListsEmpty: (options: WebRTCConfigOptions) => boolean;
-export declare const selectBestTurnServer: (turnList: string[]) => Promise<TurnSelectionResult>;
+export declare const selectBestTurnServerFast: (turnList: string[]) => Promise<TurnSelectionResult>;

package/lib/index.d.ts

@@ -1,12 +1,12 @@
 import { WebRTCSdk } from './core/WebRTCSdk';
 import { getKeyEventData } from "./core/util/KeyCodeUtil";
-import { testMultipleTurnServers } from './core/util/TurnTestUtil';
+import { selectBestTurnServerFast } from './core/util/TurnTestUtil';
 import { transformCoordinate, valueToPercentage } from "./core/util/ScreenControlUtil";
 import { ActionType, ChannelDataType, ContainerDirection, InputData, KeyEventData, TouchData, WheelData, GestureData, type ActionCommand, ActionCommandType, ActionCommandEventType, ActionCommandEventValue, TrackEventData, ClarityData } from "./core/data/WebrtcDataType";
 import { type TurnServerConfig, type TurnTestResult, type TurnTestSummary } from "./core/data/TurnType";
 import type { WebRTCConfigOptions } from './core/rtc/WebRTCConfig';
-import { EmitType, type CameraError, type WebRtcError } from "./core/data/WebRtcError";
+import { EmitType, FailCode, type CameraError, type WebRtcError } from "./core/data/WebRtcError";
 import RemotePlayer from './components/RemotePlayer/index.vue';
 import { ConnectorType } from './core/data/MessageType';
 import { GroupCtrlSocketManager } from './core/groupctrl/GroupCtrlSocketManager';
-export { WebRTCSdk, getKeyEventData, transformCoordinate, valueToPercentage, ActionType, ChannelDataType, InputData, KeyEventData, TouchData, ContainerDirection, EmitType, WheelData, GestureData, ClarityData, type ActionCommand, ActionCommandType, type WebRTCConfigOptions, ActionCommandEventType, ActionCommandEventValue, RemotePlayer, TrackEventData, type TurnServerConfig, type TurnTestResult, type TurnTestSummary, testMultipleTurnServers, type CameraError, type WebRtcError, ConnectorType, GroupCtrlSocketManager };
+export { WebRTCSdk, getKeyEventData, transformCoordinate, valueToPercentage, ActionType, ChannelDataType, InputData, KeyEventData, TouchData, ContainerDirection, EmitType, WheelData, GestureData, ClarityData, type ActionCommand, ActionCommandType, type WebRTCConfigOptions, ActionCommandEventType, ActionCommandEventValue, RemotePlayer, TrackEventData, type TurnServerConfig, type TurnTestResult, type TurnTestSummary, type CameraError, type WebRtcError, ConnectorType, GroupCtrlSocketManager, FailCode, selectBestTurnServerFast };

package/lib/uni/KeyboardControl.d.ts

@@ -0,0 +1,53 @@
+import { InputData, KeyEventData } from "../core/data/WebrtcDataType";
+import Logger from "./Logger";
+interface KeyboardControlOptions {
+    rootContainer: HTMLElement;
+    inputDataUpdateCallback: (data: KeyEventData) => void;
+    chineseDataUpdateCallback: (data: InputData) => void;
+    videoAngle: number;
+    enabledIMEKeyboard?: boolean;
+    enabledDebug?: boolean;
+    disabled?: boolean;
+}
+declare class KeyboardControl {
+    #private;
+    logger: Logger;
+    rootContainer: HTMLElement;
+    keyboardContainerElement: HTMLElement | null;
+    inputMethodEditorElement: HTMLTextAreaElement | null;
+    inputDataUpdateCallback: KeyboardControlOptions['inputDataUpdateCallback'];
+    chineseDataUpdateCallback: KeyboardControlOptions['chineseDataUpdateCallback'];
+    videoAngle: KeyboardControlOptions['videoAngle'];
+    disabled?: boolean;
+    enabledIMEKeyboard?: boolean;
+    constructor({ rootContainer, inputDataUpdateCallback, chineseDataUpdateCallback, enabledDebug, disabled, enabledIMEKeyboard, videoAngle }: KeyboardControlOptions);
+    createKeyboardContainerElement(): HTMLDivElement;
+    createInputMethodEditor(): HTMLTextAreaElement;
+    mountNode(): void;
+    init(): void;
+    clearInput: () => void;
+    focusIME: () => void;
+    blurIME: () => void;
+    setKeyboardContainerSize(width: number, height: number): void;
+    setKeyboardContainerElementStyle(style: {
+        rotate: number;
+    }): void;
+    setVideoAngle(value: number): void;
+    openIMEKeyboard(): void;
+    closeIMEKeyboard(): void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleKeyboardContainerPointerenter: () => void;
+    handleKeyboardContainerPointerleave: () => void;
+    handleIMECompositionStart: (_e: CompositionEvent) => void;
+    handleIMECompositionEnd: (e: CompositionEvent) => void;
+    handleIMEInput: (e: Event) => void;
+    handleIMEKeyDown: (event: KeyboardEvent) => void;
+    addKeyboardContainerEvent(): void;
+    offKeyboardContainerEvent(): void;
+    addInputMethodEditorEvent(): void;
+    offInputMethodEditorEvent(): void;
+    addEvent(): void;
+    offEvent(): void;
+    destroy(): void;
+}
+export default KeyboardControl;

package/lib/uni/Logger.d.ts

@@ -0,0 +1,13 @@
+declare class Logger {
+    prefix: string;
+    enabledDebug: boolean;
+    constructor({ prefix, enabledDebug }: {
+        prefix: string;
+        enabledDebug?: boolean;
+    });
+    output(type: 'log' | 'warn' | 'error' | 'debug', ...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export default Logger;

package/lib/uni/MouseTouchControl.d.ts

@@ -0,0 +1,56 @@
+import { ActionType, TouchData, WheelData } from "../core/data/WebrtcDataType";
+import Logger from "./Logger";
+import type { Dimension, TouchEventData } from "./type";
+interface MouseTouchControlOptions {
+    remoteElement: HTMLElement | null;
+    cloudDeviceSize: Dimension;
+    streamAngle: number;
+    videoAngle: number;
+    widthRatio: number;
+    isGroup: boolean;
+    isMove: boolean;
+    touchDataUpdateCallback: (data: TouchData) => void;
+    wheelDataUpdateCallback: (data: WheelData) => void;
+    enabledDebug?: boolean;
+}
+interface PointerState {
+    x: number;
+    y: number;
+    downTime: number;
+    isDown: boolean;
+    bound: number;
+    index: number;
+    groupIndex: number;
+}
+declare class MouseTouchControl {
+    logger: Logger;
+    remoteElement: MouseTouchControlOptions['remoteElement'];
+    cloudDeviceSize: MouseTouchControlOptions['cloudDeviceSize'];
+    streamAngle: number;
+    videoAngle: number;
+    widthRatio: number;
+    isGroup: boolean;
+    pointers: Map<number, PointerState>;
+    groupIndexCounter: number;
+    isMove: boolean;
+    touchDataUpdateCallback: MouseTouchControlOptions['touchDataUpdateCallback'];
+    wheelDataUpdateCallback: MouseTouchControlOptions['wheelDataUpdateCallback'];
+    constructor({ remoteElement, isGroup, widthRatio, videoAngle, streamAngle, cloudDeviceSize, touchDataUpdateCallback, wheelDataUpdateCallback, enabledDebug, isMove }: MouseTouchControlOptions);
+    setVideoAngle(angle: number): void;
+    setStreamAngle(angle: number): void;
+    setWidthRatio(value: number): void;
+    setCloudDeviceSize(value: MouseTouchControlOptions['cloudDeviceSize']): void;
+    validateParams(): void;
+    handleWheel: (e: WheelEvent) => void;
+    handlePointerEvent: (event: PointerEvent | TouchEventData, action: ActionType, pointerId: number) => void;
+    handleMouseDown: (event: PointerEvent) => any;
+    handleMouseMove: (event: PointerEvent) => void;
+    handleMouseUp: (event: PointerEvent) => void;
+    handleMouseEnter: (event: PointerEvent) => void;
+    handleMouseLeave: (event: PointerEvent) => void;
+    addEvent(): void;
+    offEvent(): void;
+    init(): void;
+    destroy(): void;
+}
+export default MouseTouchControl;

package/lib/uni/RemoteCanvasController.d.ts

@@ -0,0 +1,11 @@
+import RemoteControllerBase from "./RemoteControllerBase";
+declare class RemoteCanvasController implements RemoteControllerBase {
+    remoteElement: HTMLElement | null;
+    audioElement?: HTMLAudioElement | null | undefined;
+    constructor();
+    startDecode(arrayBuffer: ArrayBuffer): void;
+    startPlay(track: MediaStreamTrack): void;
+    stopPlay(): void;
+    destroy(): void;
+}
+export default RemoteCanvasController;

package/lib/uni/RemoteController.d.ts

@@ -0,0 +1,23 @@
+import { CursorType } from "./constants";
+import RemoteControllerBase from "./RemoteControllerBase";
+interface RemoteControllerParams {
+    rootContainer: HTMLElement;
+    cursorType?: CursorType;
+    remoteViewBackgroundColor?: string;
+    loadedSuccess?: () => void;
+    loadedFailure?: (reason: string) => void;
+    enabledDebug?: boolean;
+}
+declare class RemoteController implements RemoteControllerBase {
+    remoteController: RemoteControllerBase;
+    constructor({ rootContainer, loadedSuccess, loadedFailure, enabledDebug, enabledDecode, cursorType, remoteViewBackgroundColor, }: RemoteControllerParams & {
+        enabledDecode: boolean;
+    });
+    get audioElement(): HTMLAudioElement;
+    get remoteElement(): HTMLElement;
+    startPlay(track: MediaStreamTrack): void;
+    startDecode(arrayBuffer: ArrayBuffer): void;
+    stopPlay(): void;
+    destroy(): void;
+}
+export default RemoteController;

package/lib/uni/RemoteVideoController.d.ts

@@ -0,0 +1,38 @@
+import { CursorType } from "./constants";
+import Logger from "./Logger";
+import RemoteControllerBase from "./RemoteControllerBase";
+interface RemoteVideoControllerParams {
+    rootContainer: HTMLElement;
+    cursorType?: CursorType;
+    remoteViewBackgroundColor?: string;
+    loadedSuccess?: () => void;
+    loadedFailure?: (reason: string) => void;
+    enabledDebug?: boolean;
+}
+declare class RemoteVideoController implements RemoteControllerBase {
+    #private;
+    rootContainer: RemoteVideoControllerParams['rootContainer'];
+    remoteElement: HTMLVideoElement | null;
+    cursorType: CursorType;
+    remoteViewBackgroundColor: string;
+    logger: Logger;
+    loadedSuccess?: () => void;
+    loadedFailure?: (reason: string) => void;
+    constructor({ rootContainer, loadedSuccess, loadedFailure, enabledDebug, cursorType, remoteViewBackgroundColor, }: RemoteVideoControllerParams);
+    validateParams(): void;
+    createVideoElement(): HTMLVideoElement;
+    mountNode(): void;
+    init(): Promise<void>;
+    documentClickListener: () => void;
+    addDocumentClick(): void;
+    offDocumentClick(): void;
+    handleMetaDataListener: () => void;
+    addEvent(): void;
+    offEvent(): void;
+    startPlay(track: MediaStreamTrack): void;
+    replaceVideoTrack(video: HTMLVideoElement, newTrack: MediaStreamTrack): void;
+    updateTrack(stream: MediaStream, newTrack: MediaStreamTrack): void;
+    stopPlay(): void;
+    destroy(): void;
+}
+export default RemoteVideoController;

package/lib/uni/WebRTCWrapper.d.ts

@@ -0,0 +1,57 @@
+import EventEmitter from "eventemitter3";
+import type { WebRTCConfigOptions } from "../core/rtc/WebRTCConfig";
+import { WebRTCSdk } from "../core/WebRTCSdk";
+import { ChannelDataType } from "../core/data/WebrtcDataType";
+import Logger from "./Logger";
+declare class WebRTCWrapper extends EventEmitter {
+    #private;
+    static EVENTS: {
+        CONNECTED: string;
+        DIRECTION_CHANGE: string;
+        RESIZE: string;
+        CLARITY_LEVEL_CHANGE: string;
+        GESTURE_MODE_CHANGE: string;
+        RECEIVE_MEDIA_STREAM_TRACK: string;
+        RECEIVE_ARRAY_BUFFER: string;
+        ERROR: string;
+        STOP_CONNECT: string;
+        STATISTIC_INFO: string;
+        CLICK_DATA: ChannelDataType;
+    };
+    logger: Logger;
+    webRtcSDKInstance: WebRTCSdk | null;
+    constructor({ connectConfig, enabledDebug }: {
+        connectConfig: WebRTCConfigOptions;
+        enabledDebug?: boolean;
+    });
+    addEvent(): void;
+    offEvents(): void;
+    startConnection(): void;
+    sendChannelData(type: ChannelDataType, data: any): void;
+    sendClickData(data: any): void;
+    sendActionWheel(data: any): void;
+    sendActionInput(data: any): void;
+    sendActionChinese(data: any): void;
+    goBack(): void;
+    goHome(): void;
+    goTask(): void;
+    enableAudio(): void;
+    disableAudio(): void;
+    /**
+     * @param level
+     * 高清: 3
+     * 标清: 2
+     * 流畅: 1
+     */
+    changeLevel(level: number): void;
+    /**
+     * @param value
+     * 发送剪贴板的内容
+     */
+    sendClipboardData(value: string): void;
+    setNavigationMode(mode: number): void;
+    switchToGestureNavigation(): void;
+    switchToThreeButtonNavigation(): void;
+    destroy(): void;
+}
+export default WebRTCWrapper;