yjz-web-sdk 1.0.11-beta.2 → 1.0.11-beta.4

package/lib/core/WebRTCSdk.d.ts

@@ -12,8 +12,6 @@ export declare class WebRTCSdk extends EventEmitter {
     options: WebRTCConfigOptions;
     isConnected: boolean;
     isConnecting: boolean;
-    private connectCount;
-    private MAX_COUNT;
     private timeout;
     constructor(options: WebRTCConfigOptions);
     initConfig(): Promise<void>;

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,6 +19,8 @@ export declare class WebRTCClient extends EventEmitter {
     private maxLostRate;
     private lastSecondDecodedCount;
     private fileVideo?;
+    private videoTransceiver?;
+    private audioTransceiver?;
     private canvas?;
     private canvasStream;
     private rafId;
@@ -37,8 +40,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;

package/lib/index.d.ts

@@ -5,8 +5,8 @@ import { transformCoordinate, valueToPercentage } from "./core/util/ScreenContro
 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, testMultipleTurnServers, type CameraError, type WebRtcError, ConnectorType, GroupCtrlSocketManager, FailCode };

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,13 @@
+import RemoteControllerBase from "./RemoteControllerBase";
+declare class RemoteCanvasController implements RemoteControllerBase {
+    remoteElement: HTMLElement | null;
+    audioElement?: HTMLAudioElement | null | undefined;
+    constructor({ remoteElement }: {
+        remoteElement: HTMLElement;
+    });
+    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>;