quickvo-sdk-js 1.5.17 → 1.6.0

package/README.md

@@ -30,10 +30,10 @@
 
 ```ts
 type T_mediaType = {
-  readonly microphoneCamera_audio: '麦克风-默认轨道'
-  readonly microphoneCamera_video: '摄像头-默认轨道'
-  readonly screenSharing_video: '屏幕共享-视频轨道'
-  readonly screenSharing_audio: '屏幕共享-音频轨道'
+  readonly mc_audio: '麦克风-默认轨道'
+  readonly mc_video: '摄像头-默认轨道'
+  readonly ss_video: '屏幕共享-视频轨道'
+  readonly ss_audio: '屏幕共享-音频轨道'
 }
 type K_mediaType = keyof T_mediaType
 ```
@@ -216,11 +216,11 @@ export const quickvo = new QuickVO({ appid: 'A6B499768801DJT8ACA11E5F842DB6DF' }
 
 ```vue
 <template>
-  <video ref="microphoneCamera_audio_ref"></video>
+  <video ref="mc_audio_ref"></video>
 </template>
 
 <script setup lang="ts">
-const microphoneCamera_audio_ref = ref<HTMLVideoElement>()
+const mc_audio_ref = ref<HTMLVideoElement>()
 </script>
 ```
 
@@ -239,9 +239,9 @@ quickvo.addNotify({
     const { id, updateStreams } = user
 
     // 需要更新 麦克风
-    if (updateStreams['microphoneCamera_audio']) {
-      const stream = await quickvo.getUserStream(id, 'microphoneCamera_audio')
-      const dom = microphoneCamera_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
+    if (updateStreams['mc_audio']) {
+      const stream = await quickvo.getUserStream(id, 'mc_audio')
+      const dom = mc_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
       dom.srcObject = stream
 
       // 下面的几行代码是非必须的 但是还是建议这样做 先暂停再播放 防止重复赋值播放带来的警告或异常错误
@@ -252,13 +252,13 @@ quickvo.addNotify({
       }
     }
 
-    if (updateStreams['microphoneCamera_video']) {
+    if (updateStreams['mc_video']) {
       // ...
     }
-    if (updateStreams['screenSharing_audio']) {
+    if (updateStreams['ss_audio']) {
       // ...
     }
-    if (updateStreams['screenSharing_video']) {
+    if (updateStreams['ss_video']) {
       // ...
     }
   }
@@ -269,22 +269,22 @@ quickvo.addNotify({
 
 - 通常如果应用层需要实现本地预览麦克风、摄像头等待发布的媒体流时，你可以尝试调用该 api，目前支持开启以下四种类型：
 
-1. 麦克风 microphoneCamera_audio
-2. 摄像头 microphoneCamera_video
-3. 屏幕音频 screenSharing_audio （由于浏览器内部机制，不能单独选择该媒体，因此在选择屏幕音频时，直接设置共享屏幕音视频）
-4. 屏幕视频 screenSharing_video （如果你需要单独共享屏幕画面 而不共享屏幕音频才考虑选择该类型，更多的建议直接开启 screenSharing_audio 然后主动控制流媒体的发布、暂停）
+1. 麦克风 mc_audio
+2. 摄像头 mc_video
+3. 屏幕音频 ss_audio （由于浏览器内部机制，不能单独选择该媒体，因此在选择屏幕音频时，直接设置共享屏幕音视频）
+4. 屏幕视频 ss_video （如果你需要单独共享屏幕画面 而不共享屏幕音频才考虑选择该类型，更多的建议直接开启 ss_audio 然后主动控制流媒体的发布、暂停）
 
 ```ts
 /**
  * 设置本地流
  * @param mediaType MediaType
  * @param active 激活状态
- * @example quickvo.setLocalStream(['microphoneCamera_audio'], false)
+ * @example quickvo.setLocalStream(['mc_audio'], false)
  * @returns Promise<Streams>
  */
-quickvo.setLocalStream(['microphoneCamera_audio'], true).then((streams) => {
+quickvo.setLocalStream(['mc_audio'], true).then((streams) => {
   // 因考虑到易用性（与 onLocalStream 保持一致） 这里会返回所有本地流对象
-  const stream = streams['microphoneCamera_audio']
+  const stream = streams['mc_audio']
   // 拿到所需要的 stream 然后进行渲染 (这里以原生js使用方式作为参考)
   document.querySelector<HTMLVideoElement>('#my-dom-view')?.srcObject = stream
 })
@@ -314,15 +314,15 @@ quickvo.joinRoom(options)
  * 发布流
  * @param mediaTypes MediaType[]
  * @param count 发布失败重试次数
- * @example quickvo.publish(['microphoneCamera_audio', 'microphoneCamera_video'], 3)
+ * @example quickvo.publish(['mc_audio', 'mc_video'], 3)
  * @returns Promise<RoomUser>
  */
-quickvo.publish(['microphoneCamera_audio', 'microphoneCamera_video'], 3).then((user) => {
+quickvo.publish(['mc_audio', 'mc_video'], 3).then((user) => {
   const { id, updateStreams } = user
   // 需要更新 麦克风
-  if (updateStreams['microphoneCamera_audio']) {
-    const stream = await quickvo.getUserStream(id, 'microphoneCamera_audio')
-    const dom = microphoneCamera_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
+  if (updateStreams['mc_audio']) {
+    const stream = await quickvo.getUserStream(id, 'mc_audio')
+    const dom = mc_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
     dom.srcObject = stream
   }
 })
@@ -344,9 +344,9 @@ quickvo.subscribe(['123']).then((users) => {
   for (const user of users) {
     const { id, updateStreams } = user
     // 需要更新 麦克风
-    if (updateStreams['microphoneCamera_audio']) {
-      const stream = await quickvo.getUserStream(id, 'microphoneCamera_audio')
-      const dom = microphoneCamera_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
+    if (updateStreams['mc_audio']) {
+      const stream = await quickvo.getUserStream(id, 'mc_audio')
+      const dom = mc_audio_ref.value // 当然 如果你使用原生js，那么这里也只需要拿到对应的dom
       dom.srcObject = stream
     }
   }
@@ -421,8 +421,8 @@ quickvo.quitRoom()
 
 以下是升级指南:
 在任何调用 inactiveTracks 的地方 全部修改为 pauseTracks。( 注意：第二个参数 boolean 相反 前者描述的是启用什么轨道 后者描述的是暂停什么轨道 )
-如 quickvo.inactiveTracks(['microphoneCamera_video'], false) // 冻结视频轨道
-修改为 quickvo.pauseTracks。(['microphoneCamera_video'], true) // 暂停视频轨道
+如 quickvo.inactiveTracks(['mc_video'], false) // 冻结视频轨道
+修改为 quickvo.pauseTracks。(['mc_video'], true) // 暂停视频轨道
 
 
 ```
@@ -440,18 +440,18 @@ quickvo.quitRoom()
 由原来的
 quickvo.subscribe(['trackName1','trackName2'])
 调整为
-quickvo.subscribe([{ userId: '123', mediaTypes: ['microphoneCamera_audio', 'microphoneCamera_video'] }])
+quickvo.subscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
 
 由原来的
 quickvo.stopSubscribe(['trackName1','trackName2'])
 调整为
-quickvo.stopSubscribe([{ userId: '123', mediaTypes: ['microphoneCamera_audio', 'microphoneCamera_video'] }])
+quickvo.stopSubscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
 
 SDK内部提供了方便开发者升级的api：
 /**
 * getUsersMediaTypeBytrackNames
 * @param trackNames string[]
-* @returns [{ userId: '123', mediaTypes: ['mediaTypes', 'microphoneCamera_video'] }]
+* @returns [{ userId: '123', mediaTypes: ['mediaTypes', 'mc_video'] }]
 */
 
 const usersMediaType = quickvo.getUsersMediaTypeBytrackNames(['trackName1','trackName2'])

package/dist/QuickVO.d.ts

@@ -1,28 +1,68 @@
-import { Room } from './room/Room';
-import { Notify, QuickOptions } from './types';
-export declare class QuickVO extends Room {
-    #private;
+import { QuickOptions } from './types';
+export declare class QuickVO {
+    private _base;
+    private _ACTION_BASE;
+    private _ACTION_SFU;
+    private _ACTION_P2P;
     constructor(options: QuickOptions);
-    /**
-     * addNotify
-     * @param notify Notify
-     * @returns sn
-     */
-    addNotify: (notify: Notify) => string;
-    /**
-     * add FrameRequestCallback
-     * @param key string
-     * @param func FrameRequestCallback
-     */
+    recorder: import('./base/modules/StreamRecorder').StreamRecorder;
     addRequestAnimationFrame: (key: string, func: FrameRequestCallback) => Promise<void>;
-    /**
-     * clear FrameRequestCallback
-     * @param keys string[] = []
-     */
     clearRequestAnimationFrame: (keys?: string[]) => Promise<number[]>;
-    /**
-     * destroy
-     * @example quickvo.destroy()
-     */
-    destroy: () => Promise<void>;
+    addNotify: (notify: {
+        sn?: string;
+        event: "onJoinRoom" | "onQuitRoom" | "onBeforeTokenExpire" | "onTokenExpired" | "onDestroyRoom" | "onCDNPlayUrlAdd" | "onRoomUserSpeech" | "onRoomUsers" | "onRoomNetwork" | "onPeerState" | "onRoomState";
+        callback?: (e: any) => void;
+    }) => string;
+    setOptions: (options: QuickOptions) => void;
+    getLocalStream: (mediaType: import('./enums/mediaType').K_mediaType) => MediaStream;
+    getLocalStreams: () => {
+        mc_audio: MediaStream;
+        mc_video: MediaStream;
+        ss_video: MediaStream;
+        ss_audio: MediaStream;
+    };
+    setActiveNoise: (mediaType: import('./enums/mediaType').K_mediaType, state: boolean) => void;
+    getUserContent: (userId?: string) => import('./base/modules/users/modules/LocalUser').LocalUser | import('./base/modules/users/modules/RemoteUser').RemoteUser | undefined;
+    getUserStream: (userId: string, mediaType: import('./enums/mediaType').K_mediaType) => MediaStream | undefined;
+    getVolume: (userId: string, mediaType: import('./enums/mediaType').K_mediaType) => number | undefined;
+    getMaxVolumeUser: () => {
+        id: string;
+        volume: number;
+    } | undefined;
+    setInputVolume: (userId: string, mediaType: import('./enums/mediaType').K_mediaType, gain: number) => void;
+    setEnhanceGain: (userId: string, mediaType: import('./enums/mediaType').K_mediaType, gain: number) => Promise<void>;
+    setSpeakerVolume: (userId: string, mediaType: import('./enums/mediaType').K_mediaType, gain: number) => void;
+    getUserAudioMediaStreamContext: (userId: string, mediaType: import('./enums/mediaType').K_mediaType) => import('pr-audio-stream').PrAudioStream | undefined;
+    getEnumerateDevices: (mediaDeviceKind: MediaDeviceKind) => Promise<MediaDeviceInfo[]>;
+    getMediaDevicesErrInfo: () => Promise<{
+        mc_audio: string;
+        mc_video: string;
+    }>;
+    setCallStrategy: (callStrategy: import('./enums/callStrategy').K_callStrategy, mediaTypes?: import('./enums/mediaType').K_mediaType[]) => Promise<void>;
+    getReportsByMid: () => never[];
+    setLocalStream: (mediaTypes: import('./enums/mediaType').K_mediaType[], active: boolean) => Promise<unknown>;
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<unknown>;
+    setMediaTrackConstraints: (mediaType: import('./enums/mediaType').K_mediaType, constraints: MediaTrackConstraints) => Promise<void>;
+    earlyConnect: (mediaTypes?: import('./enums/mediaType').K_mediaType[]) => Promise<unknown>;
+    joinRoom: (roomOptions: import('./types').RoomOptions) => Promise<unknown>;
+    publish: (mediaTypes: import('./enums/mediaType').K_mediaType[]) => Promise<boolean>;
+    stopPublish: (mediaTypes: import('./enums/mediaType').K_mediaType[]) => Promise<boolean>;
+    pauseTracks: (mediaTypes: import('./enums/mediaType').K_mediaType[], pause: boolean) => Promise<boolean>;
+    subscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<unknown>;
+    stopSubscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<boolean>;
+    toggleRoomSpeechLang: (data: {
+        input: string;
+        output: string;
+        translateEnable?: boolean;
+    }) => void;
+    updateToken: (sdkToken: string) => void;
+    quitRoom: () => Promise<boolean>;
+    quitRoomEx: () => Promise<boolean>;
+    destroy: () => void;
+    getLocalUserTrackReports: (mediaType: import('./enums/mediaType').K_mediaType) => import('./types').TrackReport;
+    getRemoteUserTrackReports: (userId: string, origin: "sfu" | "p2p", direction: "sends" | "recvs", mediaType: import('./enums/mediaType').K_mediaType) => import('./types').TrackReport | undefined;
+    _openP2P: (remoteUserId: string, mediaTypes: import('./enums/mediaType').K_mediaType[], isRemotePush: boolean) => Promise<unknown>;
+    _restoreRoom: () => Promise<void>;
+    _debugger: () => Promise<void>;
+    _ai: () => Promise<void>;
 }

package/dist/action/ActionBase.d.ts

@@ -0,0 +1,9 @@
+import { Base } from '../base/Base';
+export declare class ActionBase {
+    base: Base;
+    constructor({ base }: {
+        base: Base;
+    });
+    _debugger: () => Promise<void>;
+    _ai: () => Promise<void>;
+}

package/dist/action/ActionP2P.d.ts

@@ -0,0 +1,12 @@
+import { K_mediaType } from '../enums/mediaType';
+import { Base } from '../base/Base';
+export declare class ActionP2P {
+    base: Base;
+    constructor({ base }: {
+        base: Base;
+    });
+    _openP2P: (remoteUserId: string, mediaTypes: K_mediaType[], isRemotePush: boolean) => Promise<unknown>;
+    private _onOffer;
+    private _onCandidate;
+    private _getRemoteUserP2PContent;
+}

package/dist/action/ActionSFU.d.ts

@@ -0,0 +1,125 @@
+import { K_mediaType } from '../enums/mediaType';
+import { RoomOptions, UserMediaTypes } from '../types';
+import { Base } from '../base/Base';
+export declare class ActionSFU {
+    base: Base;
+    constructor({ base }: {
+        base: Base;
+    });
+    /**
+     * setLocalStream
+     * @param mediaTypes K_mediaType[]
+     * @param active boolean
+     */
+    setLocalStream: (mediaTypes: K_mediaType[], active: boolean) => Promise<unknown>;
+    /**
+     * setMediaDeviceKind
+     * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
+     * @param deviceId string | undefined
+     */
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<unknown>;
+    /**
+     * setMediaTrackConstraints
+     * @param mediaType K_mediaType
+     * @param constraints MediaTrackConstraints
+     */
+    setMediaTrackConstraints: (mediaType: K_mediaType, constraints: MediaTrackConstraints) => Promise<void>;
+    /**
+     * earlyConnect
+     * @param mediaTypes ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[]
+     */
+    earlyConnect: (mediaTypes?: K_mediaType[]) => Promise<unknown>;
+    /**
+     * joinRoom
+     * @param roomOptions RoomOptions
+     * @example quickvo.joinRoom({ userId: '', roomId: '', sdkToken: '', callType: '1' , newPublishAutoSubscribe: true })
+     * @returns Promise<boolean>
+     */
+    joinRoom: (roomOptions: RoomOptions) => Promise<unknown>;
+    /**
+     * publish
+     * @param mediaTypes MediaType[]
+     * @example quickvo.publish(['mc_audio', 'mc_video'])
+     */
+    publish: (mediaTypes: K_mediaType[]) => Promise<boolean>;
+    /**
+     * stopPublish
+     * @param trackNames  string[] = []
+     * @example quickvo.stopPublish(['mc_audio'])
+     */
+    stopPublish: (mediaTypes: K_mediaType[]) => Promise<boolean>;
+    /**
+     * pauseTracks
+     * @param mediaTypes MediaType[]
+     * @param pause boolean
+     * @example quickvo.pauseTracks(['mc_audio'], true)
+     */
+    pauseTracks: (mediaTypes: K_mediaType[], pause: boolean) => Promise<boolean>;
+    /**
+     * subscribe
+     * @param usersMediaTypes: UserMediaTypes[] = [] 不传入订阅所有
+     * @example quickvo.subscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
+     */
+    subscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<unknown>;
+    /**
+     * stopSubscribe
+     * @param usersMediaTypes: UserMediaTypes[] = [] 不传入取消订阅所有
+     * @example quickvo.stopSubscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
+     * @returns Promise<boolean>
+     */
+    stopSubscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<boolean>;
+    /**
+     * quitRoom
+     * @example quickvo.quitRoom()
+     * @returns Promise<boolean>
+     */
+    quitRoom: () => Promise<boolean>;
+    /**
+     * quitRoom and continuously open the connection
+     * @example quickvo.quitRoomEx()
+     * @returns Promise<boolean>
+     */
+    quitRoomEx: () => Promise<boolean>;
+    /**
+     * setBanBehaviors
+     * @param usersBehaviors Array<{ id: string; banBehaviors: { [key in K_mediaType]?: boolean } }>
+     */
+    setBanBehaviors: (usersBehaviors: Array<{
+        id: string;
+        banBehaviors: { [key in K_mediaType]?: boolean; };
+    }>) => Promise<unknown>;
+    /**
+     * toggleRoomSpeechLang
+     * @param data { input: string; output: string; translateEnable?: boolean }
+     */
+    toggleRoomSpeechLang: (data: {
+        input: string;
+        output: string;
+        translateEnable?: boolean;
+    }) => void;
+    /**
+     * updateToken
+     * @param sdkToken string
+     */
+    updateToken: (sdkToken: string) => void;
+    /**
+     * destroy
+     */
+    destroy: () => void;
+    private _connectCws;
+    private _initHeartbeat;
+    private _connectCF;
+    private _createTrack;
+    private _closeTrack;
+    private _pubNotify;
+    private _renegotiate;
+    private _ackMsg;
+    private _notifySelfCallAction;
+    private _calculateNetwork;
+    private _checkAndSelectUserStreamOrigin;
+    private _reportNetwork;
+    private _hasAsyncTask;
+    private _syncRoomInfo;
+    private _restorePeer;
+    _restoreRoom: () => Promise<void>;
+}

package/dist/base/Base.d.ts

@@ -0,0 +1,54 @@
+import { Config } from './modules/Config';
+import { Traffic } from './modules/Traffic';
+import { Notifys } from './modules/Notifys';
+import { Users } from './modules/users/Users';
+import { PrIntervalQueue } from 'pr-interval-queue';
+import { LocalMedias } from './modules/LocalMedias';
+import { Peer } from './modules/Peer';
+import { CallsWebSocket } from './modules/cws/CallsWebSocket';
+import { StreamRecorder } from './modules/StreamRecorder';
+import { PrAsyncQueue } from 'pr-async-queue';
+import { K_roomState } from '../enums/roomState';
+import { K_mediaType } from '../enums/mediaType';
+type Report_Log_Type = 'ws_c_timeout' | 'webrtc_c_timeout' | 'join_room_error' | 'publish_error' | 'subscribe_error' | 'close_track_error' | 'heartbeat_e_timeout' | 'heartbeat_i_timeout' | 'quit_room_error';
+export declare class Base {
+    config: Config;
+    notifys: Notifys;
+    localMedias: LocalMedias;
+    intervalQueue: PrIntervalQueue;
+    asyncQueue: PrAsyncQueue;
+    traffic: Traffic;
+    recorder: StreamRecorder;
+    users: Users;
+    cws: CallsWebSocket;
+    peer: Peer;
+    private _requestAnimationFrameMap;
+    constructor();
+    setRoomState: (state: K_roomState) => void;
+    setPeerState: (state: RTCPeerConnectionState) => void;
+    /**
+     * add FrameRequestCallback
+     * @param key string
+     * @param func FrameRequestCallback
+     */
+    addRequestAnimationFrame: (key: string, func: FrameRequestCallback) => Promise<void>;
+    /**
+     * clear FrameRequestCallback
+     * @param keys string[] = []
+     */
+    clearRequestAnimationFrame: (keys?: string[]) => Promise<number[]>;
+    _checkUserStreamOrigin: ({ p2pAverageQuality, sfuAverageQuality }: {
+        p2pAverageQuality: number;
+        sfuAverageQuality: number;
+    }) => "sfu" | "p2p";
+    _reportP2PConnect: (state: "success" | "fail" | "ignore" | "disconnect" | "poor_network", data: {
+        action?: 0 | 1 | 2 | 3;
+        pullId: string;
+        pushId: string;
+        mediaTypes: K_mediaType[];
+        desc?: string;
+        connectedTime?: string;
+    }) => Promise<Pick<import('../protos/protoEvent').MessageRsp<"reportP2PConnectEx">, "sn" | "event" | "data" | "code" | "desc">>;
+    _reportLog: (_type: Report_Log_Type, describe?: string) => void;
+}
+export {};

package/dist/base/modules/Config.d.ts

@@ -0,0 +1,126 @@
+import { QuickOptions, RoomOptions } from '../../types';
+import { K_roomState } from '../../enums/roomState';
+export declare class Config {
+    /**
+     * 信令服务地址
+     */
+    url: string;
+    /**
+     * 应用ID
+     */
+    appid: string;
+    /**
+     * 是否开启调试模式
+     */
+    debug: boolean;
+    /**
+     * 是否上报错误信息
+     */
+    reportErr: boolean;
+    /**
+     * 日志上报地址
+     */
+    logUrl: string;
+    /**
+     * SDK凭证
+     */
+    sdkToken: string;
+    /**
+     * 房间ID
+     */
+    roomId: string;
+    /**
+     * 用户ID
+     */
+    userId: string;
+    /**
+     * 通讯类型
+     */
+    callType: number;
+    /**
+     * 是否开启语音翻译
+     */
+    stt: boolean;
+    /**
+     * 语音翻译 语言选择
+     */
+    lang: {
+        input: string;
+        output: string;
+        translateEnable: boolean;
+    };
+    /**
+     * 是否开启P2P
+     */
+    useP2P: boolean;
+    /**
+     * 新媒体流是否自动订阅
+     */
+    newPublishAutoSubscribe: boolean;
+    /**
+     * 房间状态
+     */
+    roomState: K_roomState;
+    /**
+     * 会话状态
+     */
+    peerState: RTCPeerConnectionState;
+    /**
+     * sdk服务版本
+     */
+    sdk_service_version: string;
+    /**
+     * sdk 凭证
+     */
+    sdk_session: string;
+    /**
+     * 是否开启预连接
+     */
+    isEarly: boolean;
+    /**
+     * 预连接ID
+     */
+    earlyId: string;
+    /**
+     * 是否在房间内
+     */
+    isInRoom: boolean;
+    /**
+     * sfu 优先级 如果p2p的网络质量 大于sfu网络质量+ sfuPriority 才切换至p2p 否则切换至sfu
+     */
+    sfuPriority: number;
+    /**
+     * 总网络质量
+     */
+    network: {
+        sfu: {
+            inboundBytes: number;
+            outboundBytes: number;
+            lostRate: number;
+            roundTripTime: number;
+            jitter: number;
+            quality: number;
+            averageQuality: number;
+            velocityPush: number;
+            velocityPull: number;
+        };
+        p2p: {
+            inboundBytes: number;
+            outboundBytes: number;
+            lostRate: number;
+            roundTripTime: number;
+            jitter: number;
+            quality: number;
+            averageQuality: number;
+            velocityPush: number;
+            velocityPull: number;
+        };
+    };
+    constructor();
+    /**
+     * setOptions
+     */
+    setOptions: (options: QuickOptions) => void;
+    setRoomOptions: (options: RoomOptions) => void;
+    createWsUrl: () => string;
+}

package/dist/base/modules/LocalMedias.d.ts

@@ -0,0 +1,85 @@
+import { K_mediaType } from '../../enums/mediaType';
+export declare class LocalMedias {
+    audioContext: AudioContext;
+    private phoneyStreamTracks;
+    private mediaDevices;
+    private useMediaDevices;
+    /**
+     * 媒体轨道参数管理
+     */
+    private mediaTrackConstraints;
+    private localStreamTracks;
+    constructor();
+    /**
+     *
+     * @param kind 'audio' | 'video
+     * @returns MediaStreamTrack
+     */
+    getPhoneyStreamTrack: (mediaType: K_mediaType) => MediaStreamTrack;
+    /**
+     * initLocalStreamTrack
+     */
+    initLocalStreamTrack: (mediaType: K_mediaType | "mc" | "ss") => Promise<void>;
+    getLocalStreamTrack: (mediaType: K_mediaType) => MediaStreamTrack | undefined;
+    /**
+     * checkLocalStreamTracks
+     */
+    checkLocalStreamTracks: (mediaTypes: K_mediaType[]) => {
+        valid_mediaTypes: ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[];
+        invalid_mediaTypes: ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[];
+    };
+    /**
+     * 停止本地流轨道
+     * @param mediaType
+     */
+    stopLocalStreamTrack: (mediaType: K_mediaType) => void;
+    /**
+     * 是否已开启媒体设备
+     * @param mediaType
+     * @returns boolean
+     */
+    isOpenMediaDevice: (mediaType: K_mediaType) => boolean;
+    /**
+     * setMediaTrackConstraints
+     * @param mediaType K_mediaType
+     * @param constraints MediaTrackConstraints
+     */
+    setMediaTrackConstraints: (mediaType: K_mediaType, constraints: MediaTrackConstraints) => Promise<void>;
+    /**
+     * getMediaDeviceKind
+     * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
+     * @returns deviceId string
+     */
+    getMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind) => string | undefined;
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => void;
+    /**
+     * changeAudiooutput
+     */
+    changeAudiooutput: () => Promise<void>;
+    getMediaDevicesErrInfo: () => Promise<{
+        mc_audio: string;
+        mc_video: string;
+    }>;
+    /**
+     * getEnumerateDevices
+     * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
+     * @returns MediaDeviceInfo[]
+     */
+    getEnumerateDevices: (mediaDeviceKind: MediaDeviceKind) => Promise<MediaDeviceInfo[]>;
+    /**
+     * getEnumerateAudioinputDevices
+     * @returns MediaDeviceInfo[]
+     */
+    getEnumerateAudioinputDevices: () => Promise<MediaDeviceInfo[]>;
+    /**
+     * getEnumerateAudioOutputDevices
+     * @returns MediaDeviceInfo[]
+     */
+    getEnumerateAudioOutputDevices: () => Promise<MediaDeviceInfo[]>;
+    /**
+     * getEnumerateVideoinputDevices
+     * @returns MediaDeviceInfo[]
+     */
+    getEnumerateVideoinputDevices: () => Promise<MediaDeviceInfo[]>;
+    private getAllEnumerateDevices;
+}