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

package/lib/composables/useKeyboardControl.d.ts

@@ -1,6 +1,10 @@
-import { ChannelDataType } from "../core/data/WebrtcDataType.ts";
+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,5 +1,5 @@
 import type { Ref } from 'vue';
-import { ChannelDataType } from "../core/data/WebrtcDataType.ts";
+import { ChannelDataType } from "../core/data/WebrtcDataType";
 import type { Dimension } from "../components/RemotePlayer/index.ts";
 interface MouseTouchControlOptions {
     remoteVideoElement: Ref<HTMLVideoElement | null>;
@@ -8,14 +8,15 @@ interface MouseTouchControlOptions {
     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: any;
+    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/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;

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

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'eventemitter3';
-import type { WebRTCConfig } from "./WebRTCConfig.ts";
-import { ChannelDataType } from "../data/WebrtcDataType.ts";
+import type { WebRTCConfig } from "./WebRTCConfig";
+import { ChannelDataType } from "../data/WebrtcDataType";
 export declare class WebRTCClient extends EventEmitter {
     private readonly config;
     private peerConnection;
@@ -9,6 +9,7 @@ export declare class WebRTCClient extends EventEmitter {
     private isPushingStream;
     private isPushingLocalStream;
     private dataChannel;
+    private videoDataChannel;
     private statsTimer;
     private lastReportTime;
     private lastBytesReceived;
@@ -18,11 +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 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;
@@ -37,8 +46,9 @@ 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 handleDataChannelMessage;
     private checkStats;
@@ -54,4 +64,7 @@ export declare class WebRTCClient extends EventEmitter {
     getFileImage(): HTMLImageElement;
     /** 停止推流并释放资源 */
     stopLocal(): void;
+    private resetIdleTimer;
+    /** 停止空闲计时器 */
+    private clearIdleTimer;
 }

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

@@ -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

@@ -3,7 +3,7 @@ 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/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.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;

package/lib/uni/constants.d.ts

@@ -0,0 +1,42 @@
+export declare enum DocumentEvent {
+    KEY_DOWN = "keydown",
+    POINTER_ENTER = "pointerenter",
+    POINTER_LEAVE = "pointerleave",
+    POINTER_DOWN = "pointerdown",
+    POINTER_UP = "pointerup",
+    POINTER_MOVE = "pointermove",
+    WHEEL = "wheel",
+    COMPOSITION_START = "compositionstart",
+    COMPOSITION_END = "compositionend",
+    INPUT = "input"
+}
+export declare enum MenuKey {
+    HOME = 3,
+    BACK = 4,
+    TASK = 187
+}
+export declare enum ClarityLevel {
+    FLUENT = 1,// 流畅
+    STANDARD = 2,// 标清
+    HIGH_DEFINITION = 3
+}
+export declare const CLARITY_LEVEL_LIST: {
+    label: string;
+    value: ClarityLevel;
+}[];
+export declare enum GestureMode {
+    THREE_BUTTON_NAVIGATION = 0,
+    GESTURE_NAVIGATION = 2
+}
+export declare const CLASS_NAME: {
+    CONTAINER_CLASS_NAME: string;
+    KEYBOARD_CONTAINER_CLASS_NAME: string;
+    REMOTE_VIDEO_CLASS_NAME: string;
+    INPUT_METHOD_EDITOR_CLASS_NAME: string;
+};
+export declare enum CursorType {
+    DEFAULT_CURSOR = 0,
+    CIRCLE_CURSOR = 1,
+    TRIANGLE_CURSOR = 2
+}
+export declare const cursorClassMap: Record<CursorType, string>;

package/lib/uni/index.d.ts

@@ -0,0 +1,110 @@
+import EventEmitter from 'eventemitter3';
+import { type WebRTCConfigOptions } from '../core/rtc/WebRTCConfig';
+import RemoteController from './RemoteController';
+import MouseTouchControl from './MouseTouchControl';
+import KeyboardControl from './KeyboardControl';
+import WebRTCWrapper from './WebRTCWrapper';
+import Logger from './Logger';
+import { ClarityLevel, CursorType } from './constants';
+import { Dimension, MakeOptional } from './type';
+interface SDKParams {
+    mountedElement: string | HTMLElement;
+    connectConfig: MakeOptional<WebRTCConfigOptions, 'isGroup'>;
+    cloudDeviceSize?: Dimension;
+    cursorType?: number;
+    remoteViewBackgroundColor?: string;
+    videoAngle?: number;
+    isGroup?: boolean;
+    disabledVerticalSwipe?: boolean;
+    disabled?: boolean;
+    enabledDebug?: boolean;
+    enabledIMEKeyboard?: boolean;
+    enabledDecode?: boolean;
+}
+declare enum SDKEvents {
+    CHANNEL_EVENT = "channelEvent",
+    GROUP_CONTROL_EVENT = "groupControlEvent",
+    LOADED_SUCCESS = "loadedSuccess",
+    LOADED_FAILURE = "loadedFailure"
+}
+declare class UniSDK extends EventEmitter {
+    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: import("../index").ChannelDataType;
+        CHANNEL_EVENT: SDKEvents.CHANNEL_EVENT;
+        GROUP_CONTROL_EVENT: SDKEvents.GROUP_CONTROL_EVENT;
+        LOADED_SUCCESS: SDKEvents.LOADED_SUCCESS;
+        LOADED_FAILURE: SDKEvents.LOADED_FAILURE;
+    };
+    static CURSOR_TYPE: typeof CursorType;
+    static CLARITY_LEVEL: typeof ClarityLevel;
+    static CLARITY_LEVEL_LIST: {
+        label: string;
+        value: ClarityLevel;
+    }[];
+    logger: Logger;
+    mountedElement: SDKParams['mountedElement'];
+    connectConfig: SDKParams['connectConfig'];
+    cloudDeviceSize: SDKParams['cloudDeviceSize'];
+    videoContainerElement: HTMLDivElement | null;
+    containerResizeObserver: ResizeObserver | null;
+    remoteViewBackgroundColor: string;
+    remoteController: RemoteController | null;
+    webRtcSDKInstance: WebRTCWrapper | null;
+    mouseTouchControl: MouseTouchControl | null;
+    keyboardControl: KeyboardControl | null;
+    isGroup: boolean;
+    videoAngle: number;
+    streamAngle: number;
+    widthRatio: number;
+    heightRatio: number;
+    cursorType: CursorType;
+    disabled: boolean;
+    enabledDebug: boolean;
+    disabledVerticalSwipe: boolean;
+    enabledIMEKeyboard: boolean;
+    enabledDecode: boolean;
+    constructor({ mountedElement, connectConfig, cloudDeviceSize, disabled, enabledDebug, isGroup, disabledVerticalSwipe, enabledIMEKeyboard, remoteViewBackgroundColor, videoAngle, cursorType, enabledDecode }: SDKParams);
+    setVideoAngle(angle: number): void;
+    getVideoAngle(): number;
+    setStreamAngle(angle: number): void;
+    setCloudDeviceSize(value: Dimension): void;
+    validateParams(): boolean;
+    init(): void;
+    createVideoContainerElement(): HTMLDivElement;
+    setKeyboardContainerSize(width: number, height: number): void;
+    createNode(): void;
+    calculateSize(w: number, h: number): void;
+    addContainerResizeListener(): void;
+    offContainerResizeListener(): void;
+    addEvent(): void;
+    offEvents(): void;
+    createRemoteController(): RemoteController;
+    createMouseTouchControl(remoteElement: HTMLElement): MouseTouchControl;
+    createKeyboardControl(): KeyboardControl;
+    mounted(): Promise<void>;
+    startConnection(): void;
+    goBack(): void;
+    goHome(): void;
+    goTask(): void;
+    enableAudio(): void;
+    disableAudio(): void;
+    changeLevel(value: number): void;
+    sendClipboardData(value: string): void;
+    openIMEKeyboard(): void;
+    closeIMEKeyboard(): void;
+    switchToGestureNavigation(): void;
+    switchToThreeButtonNavigation(): void;
+    destroy(): void;
+}
+export * from './type';
+export { UniSDK };

package/lib/uni/type.d.ts

@@ -0,0 +1,10 @@
+export interface Dimension {
+    width: number;
+    height: number;
+}
+export interface TouchEventData {
+    clientX: number;
+    clientY: number;
+    timeStamp: DOMHighResTimeStamp;
+}
+export type MakeOptional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;