larksr_websdk 3.2.38 → 3.2.311

package/dist/types/api.d.ts

@@ -33,6 +33,8 @@ export interface GetTaskResult {
     updateDate: string;
     useGamepad: number;
     wm: number;
+    textInputEventPrompt: number;
+    audioInput: number;
 }
 export interface StartAppInfo {
     appliId: string;
@@ -108,7 +110,7 @@ export default class API {
         appKey?: string;
         timestamp?: string;
         signature?: string;
-    }): Promise<StartAppInfo>;
+    } | any): Promise<StartAppInfo>;
     static CheckUTLockInfo(config: ILarkSRConfig): Promise<UTLockInfo>;
     static GetTask(config: ILarkSRConfig, taskid: string): Promise<GetTaskResult>;
     static LogError(errorCode: number, errorMsg: string, params: string, config: ILarkSRConfig): void;

package/dist/types/appli_params.d.ts

@@ -190,6 +190,9 @@ export interface IAppliParams {
     toastLevel: number;
     appKey: string;
     groupId: string;
+    textInputEventPrompt: boolean;
+    audioInput: boolean;
+    audioInputAutoStart: boolean;
 }
 export declare enum AppliType {
     DESKTOP = 1,
@@ -249,6 +252,9 @@ export declare class AppliParams implements IAppliParams {
     toastLevel: number;
     appKey: string;
     groupId: string;
+    textInputEventPrompt: boolean;
+    audioInput: boolean;
+    audioInputAutoStart: boolean;
     static copyAndCreate(params?: IAppliParams): AppliParams;
     static setUpWithSDKConfig(params: IAppliParams, config: ILarkSRConfig): AppliParams;
 }

package/dist/types/common/cmd.d.ts

@@ -0,0 +1,28 @@
+declare const enum CMD {
+    SESSIONKEY = 1,
+    APPSTART = 2,
+    VIDEO = 3,
+    MOUSE_DOWN = 4,
+    MOUSE_UP = 5,
+    MOUSE_MOVE = 6,
+    KEY_DOWN = 7,
+    KEY_UP = 8,
+    KEY_PRESS = 9,
+    CONNECT_APP_SERVER = 10,
+    APP_SERVER_CONNECTED = 11,
+    APP_SERVER_CONNECT_FAILED = 12,
+    CONNECT_ALREADY_EXIST = 13,
+    MOUSE_RIGHT = 14,
+    MOUSE_WHEELE = 15,
+    WEBRTC_GETICESERVER = 16,
+    WEBRTC_GET_REMOTE_ICECANDIDATE = 17,
+    WEBRTC_CALL = 18,
+    WEBRTC_ADD_ICECANDIDATE = 19,
+    WEBRTC_HANGUP = 20,
+    WEBRTC_GETDEVICELIST = 21,
+    REMOTE_APP_CLOSE = 22,
+    MOUSE_BUTTON = 23,
+    KEEP_ALIVE = 24,
+    REMOTE_APP_COUSOR_CHANGE = 25
+}
+export default CMD;

package/dist/types/common/constant.d.ts

@@ -0,0 +1,4 @@
+export declare const VIDEO_ID = "video";
+export declare const IMAGE_CURSOR_ID = "cursorid";
+export declare const EMPTY_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAADUlEQVQYV2P4//8/IwAI/QL/+TZZdwAAAABJRU5ErkJggg==";
+export declare const TOKEN_EXPIRED = "TOKEN_EXPIRED";

package/dist/types/common/interface.d.ts

@@ -0,0 +1,30 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Vector {
+    x: number;
+    y: number;
+    startPoint: Point;
+    endPoint: Point;
+}
+export interface Stage {
+    width: number;
+    height: number;
+    Position: Point;
+}
+export interface CSSPosition {
+    top: number;
+    left: number;
+}
+export interface ViewPort {
+    width: number;
+    height: number;
+}
+export interface Toggle {
+    show: boolean;
+}
+export interface OffsetView {
+    offsetX: number;
+    offsetY: number;
+}

package/dist/types/event/event_base.d.ts

@@ -0,0 +1,11 @@
+export interface LocalEvent<E> {
+    type: E;
+    target?: any;
+}
+export declare type Callback<E> = (e: E, ...params: any[]) => void;
+export declare abstract class EventBase<T, E extends LocalEvent<T>> {
+    private listeners;
+    on(type: T, callback: Callback<E>, self?: any): void;
+    off(type: T, callback: Callback<E>, self?: any): void;
+    emit(event: E, ...params: any[]): void;
+}

package/dist/types/event/iframe_poster.d.ts

@@ -0,0 +1,9 @@
+import { LarkEventType } from '../lark/lark_event_type';
+import { LarkSR } from '../larksr';
+export declare const PREX = "pxymessage";
+export declare const LOG_ERROR_EVENT_TYPE: LarkEventType[];
+export default class IframeHandler {
+    larksr: LarkSR;
+    constructor(larksr: LarkSR);
+    listenParent(): void;
+}

package/dist/types/lark/application.d.ts

@@ -0,0 +1,176 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import WebSocektChannel from './websocket_channel';
+import { RTCMediaTrackBinding } from './peer_connection';
+import WebsocketProxy from './websocket_proxy';
+import { LarkSR } from '../larksr';
+import PixelStreamingWebsocketChannel from './test_pixel_streaming';
+import { RECORDER_STATE } from './recoder';
+export declare enum APP_STATE {
+    BEFORE_CREATE = 0,
+    INITED = 1,
+    WEBSOCKET_CHANNEL_OPEN = 2,
+    LOGIN_SUCCESS = 3,
+    RTC_CONNECTED = 4,
+    MEDIA_LOADED = 5,
+    MEDIA_PLAED = 6,
+    RTC_RETRY = 7,
+    APP_RETRY = 8,
+    BEFORE_DESTORY = 9,
+    WEBSOCKET_CLOSED = 10,
+    RTC_CLOSED = 11,
+    DESTROYED = 12
+}
+export declare enum APP_EVENT_TYPE {
+    CONNECT = 0,
+    LOGIN = 1,
+    ERROR = 2,
+    INFO = 3,
+    APP_CLOSE = 4,
+    REMOTE_STREAM = 5,
+    REMOTE_AUDIO_STREAM = 6,
+    SYNC_CURSORSTYLE = 7,
+    APP_STATE_CHANGE = 8,
+    NET_STATE = 9,
+    LK_APP_RESIZE = 10,
+    LK_APP_MOUSE_MODE = 11,
+    LK_APP_PLAER_LIST = 12,
+    LK_APP_REQUEST_TEXT = 13,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 14,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 15,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 16,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 17,
+    AI_VOICE_STATUS = 18,
+    AI_VOICE_ASR_RESULT = 19,
+    AI_VOICE_DM_RESULT = 20,
+    AI_VOICE_ERROR = 21
+}
+export interface AppEvent extends LocalEvent<APP_EVENT_TYPE> {
+    data?: any;
+    state: APP_STATE;
+}
+export default class Application extends EventBase<APP_EVENT_TYPE, AppEvent> {
+    private websocketChannel;
+    private websocketProxy;
+    private testPixelStreaming;
+    private peerConnection;
+    get state(): APP_STATE;
+    set state(state: APP_STATE);
+    private _state;
+    get audioDeviceId(): string | undefined;
+    get audioTrack(): MediaStreamTrack | undefined;
+    private retryTime;
+    private larksr;
+    get voiceId(): number;
+    get recodeState(): RECORDER_STATE;
+    private recoder;
+    constructor(larksr: LarkSR);
+    init(): void;
+    initPc(): void;
+    releasePc(): void;
+    clear(): void;
+    changeOperater(uid: number): void;
+    inputText(text: string): void;
+    sendTextToDataChannel(text: string): void;
+    sendBinaryToDataChannel(binary: Uint8Array): void;
+    aiDmTextInput(text: string): number;
+    startAiDmVoiceInput(): Promise<number>;
+    stopAiDmVoiceInput(): number;
+    private onRecoderData;
+    start(): Promise<void>;
+    connect(): Promise<PixelStreamingWebsocketChannel> | Promise<WebsocketProxy> | Promise<WebSocektChannel> | undefined;
+    disConnect(): void;
+    closeRtc(): void;
+    versionCheck(): void;
+    task(): void;
+    startSteam(): void;
+    startMonitorSteam(): void;
+    restart(): void;
+    restartApp(): void;
+    rtcOffer(): void;
+    setAnswer(sdp: string): void;
+    setIce(sdpMlineindex: number, sdpmid: string, candidate: string): void;
+    sendInput(input: Msg.CloudLark.ClientInput): void;
+    sendInputBuffer(buffer: ArrayBuffer): void;
+    private sendToWebsocektChannelBuffer;
+    private sendToWebsocektChannelMsg;
+    private onChannelOpen;
+    private onClose;
+    private onChannelMsg;
+    private onVersionCheckResponse;
+    private onTaskResponse;
+    private onStartStreamResponse;
+    private onStartMonitorResponse;
+    private onWebRtcOfferAnswer;
+    private onWebRtcIcecandidate;
+    private onWebRtcError;
+    private onAppProcess;
+    private onLogout;
+    private onLocalSdp;
+    private onLoacalIce;
+    private onRemoteStream;
+    private onAudioRemoteStream;
+    private onRtcError;
+    private onIceStateChange;
+    retryPeerconnection(): void;
+    setAudioEnable(enable: boolean): void | undefined;
+    setVideoEnable(enable: boolean): void | undefined;
+    setShareEnable(enable: boolean): void | undefined;
+    closeAudio(): boolean | undefined;
+    closeVideo(): boolean | undefined;
+    closeShare(): boolean | undefined;
+    openAudio(deviceId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    } | undefined>;
+    openVideo(audio?: boolean, cameraId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    } | undefined>;
+    openDefaultMedia(video?: boolean, audio?: boolean): Promise<void | undefined>;
+    openShareMediaDevice(): Promise<void | undefined>;
+    getConnectedAudioinputDevices(): Promise<MediaDeviceInfo[] | undefined>;
+    getConnectedAudioOutputDevices(): Promise<MediaDeviceInfo[] | undefined>;
+    getConnectedVideoinputDevices(): Promise<MediaDeviceInfo[] | undefined>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<MediaDeviceInfo[] | undefined>;
+    openAudioDevice(deviceId: string, kind?: "audioinput" | "audiooutput"): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    } | undefined>;
+    openCamera(cameraId: string, minWidth?: number, minHeight?: number): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    } | undefined>;
+    openUserMeida(constraints?: MediaStreamConstraints): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    } | undefined>;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean | undefined;
+    removeMediaTrack(track: RTCRtpSender): boolean | undefined;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): Promise<MediaStream> | undefined;
+    private onPeerConnectionDisconnect;
+    private onBadNetwork;
+    private onPixelStreamingPlayerList;
+    private onPixelStreamingDataChannelState;
+    private onPixelStreamingDataChannelData;
+    private onCursorStyle;
+    private onAppResize;
+    private onAppMouseMode;
+    private onAppPlayerList;
+    private onAppRequestText;
+    private onDataChannelText;
+    private onDataChannelBinary;
+    private onDataChannelOpen;
+    private onDataChannelClose;
+    private onPeerConnectionState;
+    private onAiVoiceStatus;
+    private onAiVoiceAsrResult;
+    private onAiVoiceDMResult;
+    private onAiVoiceError;
+    appStateChange(state: APP_STATE): void;
+    private infoMsg;
+    private errorMsg;
+    private toastMsg;
+    private $emit;
+    private createAppEvent;
+}

package/dist/types/lark/custom.d.ts

@@ -0,0 +1,7 @@
+// declare module "worker-loader!*" {
+//   class WebpackWorker extends Worker {
+//     constructor();
+//   }
+
+//   export = WebpackWorker;
+// }

package/dist/types/lark/ice_candiadate_parser.d.ts

@@ -0,0 +1,24 @@
+export default class IceCandidateParser {
+    sdpMLineIndex: number | null;
+    sdpMid: string | null;
+    usernameFragment: string | null;
+    header: string;
+    private props;
+    constructor(ice: RTCIceCandidateInit);
+    get foundation(): string;
+    set foundation(f: string);
+    get component(): string;
+    set component(f: string);
+    get protocol(): string;
+    set protocol(p: string);
+    get priority(): string;
+    set priority(p: string);
+    get ip(): string;
+    set ip(ip: string);
+    get port(): string;
+    set port(port: string);
+    get type(): string;
+    get candidate(): string;
+    genNewIceCandidateInit(): RTCIceCandidateInit;
+    genNewIceCandidate(): RTCIceCandidate;
+}

package/dist/types/lark/lark_event_type.d.ts

@@ -0,0 +1,111 @@
+export declare enum LarkEventType {
+    LK_WEB_CLIENT_LOAD_SUCCESS = 1,
+    LK_TASK_CREATE_SUCCESS = 10,
+    LK_TASK_CREATE_FAILED = 11,
+    LK_TASK_SYNC_APP = 20,
+    LK_TASK_SYNC_APP_FAILED = 21,
+    LK_RENDER_SERVER_CONNECTED = 100,
+    LK_RENDER_SERVER_FAILED = 101,
+    LK_RENDER_SERVER_CLOSE = 102,
+    LK_RENDER_SERVER_ERROR = 103,
+    LK_PROXY_SERVER_CONNECTED = 200,
+    LK_PROXY_SERVER_FAILED = 201,
+    LK_PROXY_SERVER_CLOSE = 202,
+    LK_PROXY_SERVER_ERROR = 203,
+    LK_VERSION_CHECK_SUCCESS = 300,
+    LK_VERSION_CHECK_FAILED = 301,
+    LK_TASK_SUCCESS = 400,
+    LK_TASK_NOTFOUND = 401,
+    LK_TASK_SERVER_ERROR = 402,
+    LK_TASK_APP_WRONGPARAM = 403,
+    LK_TASK_NO_GPU_RESOURCE = 404,
+    LK_START_STREAM_SUCCESS = 500,
+    LK_START_STREAM_PROCESS_START_FAILED = 501,
+    LK_START_STREAM_PROCESS_START_TIMEOUT = 502,
+    LK_START_STREAM_NOT_STREAMING = 503,
+    LK_START_STREAM_ENCODER_ERROR = 504,
+    LK_RTC_EVENT_PEERCONNECTION_CONNECTED = 600,
+    LK_RTC_EVENT_PEERCONNECTION_CLOSED = 601,
+    LK_RTC_EVENT_PEERCONNECTION_ERROR = 602,
+    LK_RTC_EVENT_PEERCONNECTION_CREATE_FAILED = 603,
+    LK_RTC_EVENT_PEERCONNECTION_STATE = 610,
+    LK_RTC_EVENT_PEERCONNECTION_RETRY = 611,
+    LK_VIDEO_LOADED = 700,
+    LK_VIDEO_PLAY_FAILED = 701,
+    LK_GOT_REMOTE_STREAM = 710,
+    LK_VIDEO_PLAY_SUCCSS = 711,
+    LK_NOTIFY_CLIENT_LOGOUT_PLAYER_LOGOUT = 800,
+    LK_NOTIFY_CLIENT_LOGOUT_TASKOWNER_LOGOUT = 801,
+    LK_APP_PROCESS_NOTIFI_APP_QUIT = 900,
+    LK_NO_OPERATION_TIMEOUT = 901,
+    LK_LOADING_TIMEOUT = 902,
+    LK_APP_RESIZE = 910,
+    LK_APP_MOUSE_MODE = 911,
+    LK_APP_PLAER_LIST = 912,
+    LK_APP_REQUEST_TEXT = 913,
+    LK_APP_CURSOR_STYLE = 914,
+    LK_USER_REQUEST_QUIT = 920,
+    LK_UI_RESIZE = 930,
+    LK_STARTVRSTREAM_SUCCESS = 1000,
+    LK_STARTVRSTREAM_START_PROCESS_FAILED = 1001,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_TIMEOUT = 1002,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_UDPPORT_ERROR = 1003,
+    LK_STARTVRSTREAM_START_DRIVER_RUNTIME_ENCODER_ERROR = 1004,
+    LK_WEBCLIENT_NOTIFY_ALERT = 1100,
+    LK_WEBCLIENT_NOTIFY_CONFIRM = 1101,
+    LK_WEBCLIENT_TOAST_MSG = 1102,
+    LK_USER_CAPTURE_FRAME = 2000,
+    LK_USER_CAPTURE_FRAME_WITH_EXTRA_DATA = 2001,
+    LK_REQUEST_CAPTURE_FRAME = 3000,
+    LK_REQUEST_CAPTURE_FRAME_WITH_EXTRA_DATA = 3001,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_MOVE = 10000,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_DOWN = 10001,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_UP = 10002,
+    LK_IFRAME_POSTER_OPERATE_MOUSE_WHEEL = 10003,
+    LK_IFRAME_POSTER_OPERATE_KEY_DOWN = 10010,
+    LK_IFRAME_POSTER_OPERATE_KEY_UP = 10011,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_DOWN = 10020,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_MOVE = 10021,
+    LK_IFRAME_POSTER_OPERATE_TOUCH_UP = 10022,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_BUTTON_DOWN = 10030,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_BUTTON_UP = 10031,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_TRIGGER_VALUE = 10032,
+    LK_IFRAME_POSTER_OPERATE_GAMEPAD_JOYSTICK_STATES = 10033,
+    LK_IFRAME_POSTER_FUNC_MOUSE_MODE = 10100,
+    LK_IFRAME_POSTER_FUNC_SCALE_MODE = 10101,
+    LK_IFRAME_POSTER_FUNC_RESTART_CLOUD_APP = 10102,
+    LK_IFRAME_POSTER_FUNC_WX_JS_BRIDGE_READY = 10103,
+    LK_IFRAME_POSTER_FUNC_REQUEST_PLAY_VIDEO = 10104,
+    LK_IFRAME_POSTER_UI_CONTROLLER_BAR = 10200,
+    LK_IFRAME_POSTER_UI_PLAYER_LIST = 10201,
+    LK_IFRAME_POSTER_UI_PLAYER_SHARE_URL = 10202,
+    LK_IFRAME_POSTER_UI_MOBILE_CONTROL_BALL = 10203,
+    LK_IFRMAE_POSTER_UI_MOBILE_JOYSTICK = 10204,
+    LK_IFRAME_POSTER_UI_MOBILE_VIRTUAL_KEYBOARD = 10205,
+    LK_IFRAME_POSTER_UI_MOBILE_VIRTUAL_MOUSE = 10206,
+    LK_IFRAME_POSTER_UI_MOBILE_MENU = 10207,
+    LK_IFRAME_POSTER_UI_MOBILE_FORCE_LANDSCAPE = 10208,
+    LK_IFRAME_POSTER_UI_MOBILE_TOUCH_POINT = 10209,
+    LK_IFRAME_POSTER_UI_TOAST_LEVEL = 10210,
+    LK_IFRAME_POSTER_UI_ALERT = 10211,
+    LK_IFRAME_POSTER_UI_CONFIRM = 10212,
+    LK_DATA_CHANNEL_ESTABLISHED = 20000,
+    LK_DATA_CHANNEL_RETYING = 20001,
+    LK_DATA_CHANNEL_CLOSE = 20002,
+    LK_DATA_CHANNEL_ERROR = 20003,
+    LK_DATA_CHANNEL_BINARY_MESSAGE = 20004,
+    LK_DATA_CHANNEL_TEXT_MESSAGE = 20005,
+    LK_RE_CONNECT_DATA_CHANNEL = 20100,
+    LK_CLOSE_DATA_CHANNEL = 20101,
+    LK_DATA_CHANNEL_SEND_TEXT = 20102,
+    LK_DATA_CHANNEL_SEND_BINARY = 20103,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 20200,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 20201,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 20202,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 20203,
+    LK_DATA_CHANNEL_RENDERSERVER_SEND_TEXT = 20300,
+    LK_DATA_CHANNEL_RENDERSERVER_SEND_BINARY = 20301
+}
+export default class LarkEvent {
+    static GetEventMessageByType(type: LarkEventType): string;
+}

package/dist/types/lark/message.d.ts

@@ -0,0 +1,20 @@
+import * as Msg from '../protobuf/cloudlark';
+import { LarkEventType } from './lark_event_type';
+export declare const MESSAGE_MAGIC = 538317090;
+export declare const PIXEL_STREAMING_MESSAGE_MAGIC = 539037986;
+export default class Message {
+    static emptyMsg(isPixelStreaming?: boolean): Msg.CloudLark.ToServerMessage;
+    static versionCheckRequest(isPixelStreaming: boolean): Msg.CloudLark.ToServerMessage;
+    static taskRequest(taskid: string, isInteractiveMode: boolean, isObMode: boolean, nickName: string, isPixelStreaming: boolean): Msg.CloudLark.ToServerMessage;
+    static startStreamReqeuest(request: Msg.CloudLark.IStartStreamRequest, isPixelStreaming: boolean): Msg.CloudLark.ToServerMessage;
+    static startMonitorStreamReqeuest(request: Msg.CloudLark.IVrMonitorRequest): Msg.CloudLark.ToServerMessage;
+    static rtcOfferMsg(type: string, sdp: string): Msg.CloudLark.ToServerMessage;
+    static iceMsg(sdpmid: string, sdpMlineindex: number, candidate: string): Msg.CloudLark.ToServerMessage;
+    static restartApp(): Msg.CloudLark.ToServerMessage;
+    static getTaskResponseMsg(ressponse: Msg.CloudLark.TaskResponse.Response): string;
+    static getStartStreamResponseMsg(ressponse: Msg.CloudLark.StartStreamResponse.Response): string;
+    static getCloudlarkTaskEvent(ressponse: Msg.CloudLark.TaskResponse.Response): LarkEventType;
+    static getCloudlarkStartStreamEvent(ressponse: Msg.CloudLark.StartStreamResponse.Response): LarkEventType;
+    static getCloudlarkTaskEventMsg(type: LarkEventType): string;
+    static getCloudlarkStartStreamingEventMsg(type: LarkEventType): string;
+}

package/dist/types/lark/peer_connection.d.ts

@@ -0,0 +1,171 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Input from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum IceState {
+    DISCONNECT = 1,
+    BAD = 2,
+    CONNECT = 3,
+    GOOD = 4
+}
+export declare enum WEBRTC_EVENT_TYPE {
+    GOT_REMOTE_STREAM = 0,
+    GOT_REMOTE_AUDIO_STREAM = 1,
+    ICE_STATE_CHANGE = 2,
+    LK_APP_RESIZE = 3,
+    LK_APP_MOUSE_MODE = 4,
+    LK_APP_PLAER_LIST = 5,
+    LK_APP_REQUEST_TEXT = 6,
+    LK_DATA_CHANNEL_RENDERSERVER_TEXT_MESSAGE = 7,
+    LK_DATA_CHANNEL_RENDERSERVER_BINARY_MESSAGE = 8,
+    LK_DATA_CHANNEL_RENDERSERVER_OPEN = 9,
+    LK_DATA_CHANNEL_RENDERSERVER_CLOSE = 10,
+    LK_RTC_EVENT_PEERCONNECTION_STATE = 11,
+    NET_STATE = 12,
+    SYNC_CURSORSTYLE = 13,
+    BAD_NETWORK = 14,
+    ERROR = 15,
+    RTC_SDP = 16,
+    RTC_ICECANDIDATE = 17,
+    AI_VOICE_STATUS = 18,
+    AI_VOICE_ASR_RESULT = 19,
+    AI_VOICE_DM_RESULT = 20,
+    AI_VOICE_ERROR = 21
+}
+export interface GoogleBitRate {
+    start: number;
+    min: number;
+    max: number;
+}
+export interface WebRTCEvent extends LocalEvent<WEBRTC_EVENT_TYPE> {
+    data?: any;
+}
+export declare enum OfferModeType {
+    VP8 = 1,
+    VP9 = 2,
+    H264 = 3,
+    DEFAULT = 4
+}
+export interface WebRTCConfig {
+    serverIP: string;
+    preferPubOutIp: string;
+    codeRate?: number;
+    network: 'local' | 'public';
+}
+export interface AggregatedStats {
+    timestamp: number;
+    bytesReceived: number;
+    framesDecoded: number;
+    packetsLost: number;
+    bytesReceivedStart: number;
+    framesDecodedStart: number;
+    timestampStart: number;
+    bitrate: number;
+    lowBitrate: number;
+    highBitrate: number;
+    avgBitrate: number;
+    framerate: number;
+    lowFramerate: number;
+    highFramerate: number;
+    avgframerate: number;
+    framesDropped: number;
+    framesReceived: number;
+    framesDroppedPercentage: number;
+    frameHeight: number;
+    frameWidth: number;
+    frameHeightStart: number;
+    frameWidthStart: number;
+    currentRoundTripTime: number;
+    packetsLostPerc: number;
+}
+export interface RTCMediaTrackBinding {
+    deviceId: string;
+    track: MediaStreamTrack;
+    sender: RTCRtpSender | undefined;
+}
+export default class PeerConnection extends EventBase<WEBRTC_EVENT_TYPE, WebRTCEvent> {
+    private config;
+    private pc;
+    private dataChannel;
+    private offerOptions;
+    private pcConfig;
+    private netTestTimeout;
+    private aggregatedStats;
+    private lastThrowBadNetork;
+    private lastPacktetsLost;
+    private lastPacktetsReceived;
+    private larksr;
+    private audioStream;
+    private videoStream;
+    get audioDeviceId(): string | undefined;
+    get audioTrack(): MediaStreamTrack | undefined;
+    private localAudioTrackBinding;
+    private localVideoTrackBinding;
+    private localShareTrackBinding;
+    private sdpCreateSuccess;
+    constructor(larksr: LarkSR, config: WebRTCConfig);
+    create(): void;
+    createOffer(): void;
+    close(): void;
+    setAudioEnable(enable: boolean): void;
+    setVideoEnable(enable: boolean): void;
+    setShareEnable(enable: boolean): void;
+    closeAudio(): boolean;
+    closeVideo(): boolean;
+    closeShare(): boolean;
+    private stopLocalTrackBing;
+    openAudio(deviceId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openVideo(audio?: boolean, cameraId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openDefaultMedia(video?: boolean, audio?: boolean): Promise<void>;
+    openShareMediaDevice(): Promise<void>;
+    getConnectedAudioinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedAudioOutputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedVideoinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<MediaDeviceInfo[]>;
+    openAudioDevice(deviceId: string, kind?: "audioinput" | "audiooutput"): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openCamera(cameraId: string, minWidth?: number, minHeight?: number): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openUserMeida(constraints?: MediaStreamConstraints): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean;
+    removeMediaTrack(track: RTCRtpSender): boolean;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    /**
+     * 接收到sdp
+     * @param des sdp
+     */
+    onRemoteDescription(des: RTCSessionDescriptionInit): void;
+    onReceiveCandidate(candateInit: RTCIceCandidateInit): void;
+    startNetTest(): void;
+    stopNetTest(): void;
+    sendInput(input: Input.CloudLark.ClientInput): void;
+    sendBuffer(buffer: ArrayBuffer): void;
+    sendToAppTextMsg(msg: string): void;
+    sendToAppBinaryMsg(binary: Uint8Array): void;
+    changeOperater(uid: number): void;
+    inputText(txt: string): void;
+    private getStats;
+    private getStateChrome;
+    private onBadNetWork;
+    private onDataChannelMessage;
+    private onCreateOfferSuccess;
+    private onIceCandidate;
+    private onIceStateChange;
+    private ontrack;
+    private addIceCandidate;
+    private iceStateChange;
+    private $emit;
+    private createEvent;
+}