quickvo-sdk-js 1.3.2 → 1.4.1

package/dist/room/CallsWebSocket.d.ts

@@ -18,8 +18,16 @@ export interface CallsWebSocketOptions {
 export declare class CallsWebSocket {
     #private;
     prws: PrWebSocket;
-    state: 'connecting' | 'connected' | 'closed';
+    activeTimeStamp: number;
     constructor(_options?: CallsWebSocketOptions);
+    /**
+     * fetchUrl
+     */
+    getUrl: (env?: "local" | "dev" | "prod") => Promise<void>;
+    /**
+     * afreshSend
+     */
+    afreshSends: () => void;
     clearEvents: (sns?: string[]) => void;
     /**
      * 连接
@@ -34,7 +42,7 @@ export declare class CallsWebSocket {
      * 发送消息
      * @param message Message
      */
-    sendMessage: <T = any>(_message: Message, createEvent?: boolean) => Promise<SendMessageRevolve<T>>;
+    sendMessage: <T = any>(_message: Message, onback?: boolean) => Promise<SendMessageRevolve<T>>;
     /**
      * 触发广播事件
      * @param event 事件名称

package/dist/room/P2P.d.ts

@@ -1,20 +1,147 @@
+import { K_mediaType } from '../enums/mediaType';
+import { PrResolves } from './PrResolves';
+import { UserTrack } from '../types';
+import { PeerAnalyzeStats } from './PeerAnalyzeStats';
 export declare class P2P {
-    peerIns: RTCPeerConnection;
-    constructor();
+    prResolves: PrResolves;
+    phoneyStreams: Map<K_mediaType, MediaStream>;
+    recv_peer_ins: RTCPeerConnection;
+    recv_icecandidates: RTCIceCandidate[];
+    recv_candidate_collected: boolean;
+    recv_transceiverMap: Map<"microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio", RTCRtpTransceiver>;
+    recvPeerAnalyzeStatsIns: PeerAnalyzeStats;
+    send_peer_ins: RTCPeerConnection;
+    send_icecandidates: RTCIceCandidate[];
+    send_candidate_collected: boolean;
+    send_transceiverMap: Map<"microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio", RTCRtpTransceiver>;
+    sendPeerAnalyzeStatsIns: PeerAnalyzeStats;
+    tracks: MediaStreamTrack[];
+    reports: any[];
+    getPeerStatsTimer: number;
+    constructor(phoneyStreams: Map<K_mediaType, MediaStream>);
+    onSendPeerNetwork: (_e: any) => void;
+    onRecvPeerNetwork: (_e: any) => void;
+    getPhoneyStreams: (mediaType: K_mediaType) => MediaStream;
     /**
-     * initOffer
+     * sendIceConnected
      */
-    initOffer: () => Promise<unknown>;
+    sendIceConnected: () => Promise<unknown>;
     /**
-     * initAnswer
+     * recvIceConnected
      */
-    initAnswer: (offer: RTCSessionDescriptionInit, offer_candidates: RTCIceCandidateInit[]) => Promise<unknown>;
+    recvIceConnected: () => Promise<unknown>;
+    /**
+     * sendCandidateCollected
+     */
+    sendCandidateCollected: () => Promise<unknown>;
+    /**
+     * recvCandidateCollected
+     */
+    recvCandidateCollected: () => Promise<unknown>;
+    /**
+     * getSendIcecandidates
+     */
+    getSendIcecandidates: () => Promise<RTCIceCandidate[]>;
+    /**
+     * getRecvIcecandidates
+     */
+    getRecvIcecandidates: () => Promise<RTCIceCandidate[]>;
+    /**
+     * setOffered
+     */
+    setOffered: () => Promise<unknown>;
+    /**
+     * initSender
+     */
+    initSenderPc: () => Promise<void>;
+    /**
+     * clearSenderPc
+     */
+    clearSenderPc: () => Promise<void>;
+    /**
+     * initRecvPc
+     */
+    initRecvPc: () => Promise<void>;
+    /**
+     * clearSenderPc
+     */
+    clearRecvPc: () => Promise<void>;
+    /**
+     * initSenders
+     */
+    initSenders: (tracks?: {
+        mid: string;
+        type: number;
+    }[]) => Promise<void>;
+    /**
+     * addSenders
+     */
+    addSenders: (mediaTypes?: K_mediaType[]) => Promise<("microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio")[]>;
+    /**
+     * addRecvs
+     */
+    addRecvs: (mediaTypes?: K_mediaType[]) => Promise<("microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio")[]>;
+    /**
+     * getSenderTracks
+     */
+    getSenderTracks: (mediaTypes?: K_mediaType[]) => Promise<UserTrack[]>;
+    /**
+     * getRecvTracks
+     */
+    getRecvTracks: (mediaTypes?: K_mediaType[]) => Promise<{
+        type: number;
+        enabled: boolean;
+        trackName: string;
+        location: string;
+        mid: string | null;
+        key: string;
+    }[]>;
+    /**
+     * createOffer
+     */
+    createOffer: () => Promise<RTCSessionDescriptionInit>;
+    /**
+     * setOffer
+     */
+    setOffer: (offer: RTCSessionDescriptionInit) => Promise<void>;
+    /**
+     * createAnswer
+     */
+    createAnswer: () => Promise<RTCSessionDescriptionInit>;
+    /**
+     * addCandidates
+     */
+    addCandidates: (remote_candidates: RTCIceCandidate[]) => Promise<void>;
     /**
      * setAnswer
      */
-    setAnswer: (answer: RTCSessionDescriptionInit, answer_candidates: RTCIceCandidateInit[]) => Promise<unknown>;
+    setAnswer: (answer: RTCSessionDescriptionInit, answer_candidates: RTCIceCandidateInit[]) => Promise<void>;
+    /**
+     * getTrack
+     */
+    getTrack: (mediaType: K_mediaType) => MediaStreamTrack | undefined;
+    /**
+     * getSendPeerNetwork
+     */
+    getSendPeerNetwork: () => {
+        inboundBytes: number;
+        outboundBytes: number;
+        lostRate: string;
+        roundTripTime: string;
+        jitter: string;
+        quality: number;
+        averageQuality: number;
+    };
     /**
-     * close
+     * getRecvPeerNetwork
      */
-    close: () => void;
+    getRecvPeerNetwork: () => {
+        inboundBytes: number;
+        outboundBytes: number;
+        lostRate: string;
+        roundTripTime: string;
+        jitter: string;
+        quality: number;
+        averageQuality: number;
+    };
 }

package/dist/room/PeerAnalyzeStats.d.ts

@@ -0,0 +1,40 @@
+export declare class PeerAnalyzeStats {
+    pc: RTCPeerConnection | undefined;
+    network: {
+        inboundBytes: number;
+        outboundBytes: number;
+        lostRate: string;
+        roundTripTime: string;
+        jitter: string;
+        quality: number;
+        averageQuality: number;
+    };
+    reports: any[];
+    averageQualitys: number[];
+    timer: number;
+    constructor();
+    onNetwork: (_e: typeof this.network) => void;
+    getNetwork: () => {
+        inboundBytes: number;
+        outboundBytes: number;
+        lostRate: string;
+        roundTripTime: string;
+        jitter: string;
+        quality: number;
+        averageQuality: number;
+    };
+    getAverageQuality: () => number;
+    /**
+     * start
+     */
+    start: (pc: RTCPeerConnection) => void;
+    analyzeStats: () => Promise<void>;
+    /**
+     * getReports
+     */
+    getReports: (mids?: string[]) => Promise<any[]>;
+    /**
+     * stop
+     */
+    stop: () => void;
+}

package/dist/room/PrResolves.d.ts

@@ -0,0 +1,19 @@
+type ResolveInfo = Map<string, {
+    resolve: Function;
+    timer: number;
+}>;
+export declare class PrResolves {
+    resolvesMap: Map<string, ResolveInfo>;
+    index: number;
+    constructor();
+    /**
+     *
+     * @param eventKey 唯一key
+     * @param checkFun 检测函数
+     * @param timeout 超时时间 ms
+     * @returns
+     */
+    add: (eventKey: string, checkFun?: Function, timeout?: number) => Promise<unknown>;
+    emit: (eventKey: string) => Promise<void>;
+}
+export {};

package/dist/room/RoomBase.d.ts

@@ -1,27 +1,37 @@
 import { K_roomState } from '../enums/roomState';
-import { QuickOptions, Report_Log_Type, RoomOptions, RoomUser, UserTrack } from '../types';
+import { QuickOptions, Report_Log_Type, RoomOptions, RoomUser, UserTrack, UserTracks } from '../types';
 import { CallsWebSocket, CallsWebSocketOptions } from './CallsWebSocket';
 import { K_mediaType } from '../enums/mediaType';
 import { NetworkQualityTester } from './NetworkQualityTester';
 import { StreamRecorder } from './StreamRecorder';
 import { PrAsyncQueue } from 'pr-async-queue';
 import { P2P } from './P2P';
+import { K_iceState } from '../enums/iceState';
+import { PrResolves } from './PrResolves';
 type Options = QuickOptions & RoomOptions & CallsWebSocketOptions & {
     earlyId?: string;
 };
 export declare class RoomBase {
     options: Options;
+    sfuPush: number;
+    sfuPull: number;
+    p2pPush: number;
+    p2pPull: number;
+    prResolves: PrResolves;
     sdk_service_version: string;
     sdk_session: string;
-    prohibitNotify: boolean;
     isEarly: boolean;
     isInRoom: boolean;
     asyncQueue: PrAsyncQueue;
+    await_remote_publish_users: UserTracks[];
     roomState: K_roomState;
+    iceState: K_iceState;
     createAt: number;
     cwsIns: CallsWebSocket;
     peerIns: RTCPeerConnection;
+    sfuOffsetAverageQuality: number;
     transceiverMap: Map<"microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio", RTCRtpTransceiver>;
+    transceiverTrackMap: Map<"microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio", UserTrack>;
     sendChannel: RTCDataChannel;
     receiveChannel: RTCDataChannel;
     userMap: Map<string, RoomUser>;
@@ -37,6 +47,8 @@ export declare class RoomBase {
         screenSharing_audio: string;
     };
     constructor(options: QuickOptions);
+    hasAsyncTask: (key: string) => boolean;
+    createUserUpdateStreams: (mediaTypes?: K_mediaType[]) => any;
     /**
      * reportLogs
      */
@@ -67,10 +79,15 @@ export declare class RoomBase {
      * setRoomState
      */
     setRoomState: (state: K_roomState) => void;
+    /**
+     * setIceState
+     */
+    setIceState: (state: K_iceState) => void;
     /**
      * setOptions
      */
-    setOptions: (options: Partial<Options>) => Promise<void>;
+    setOptions: (options: Partial<Options>) => Options;
+    getOptions: () => Options;
     /**
      * stopStream
      */

package/dist/room/RoomCalls.d.ts

@@ -1,5 +1,5 @@
 import { K_mediaType } from '../enums/mediaType';
-import { QuickOptions, RoomOptions, RoomUser, Streams } from '../types';
+import { QuickOptions, RoomOptions, RoomUser, Streams, UserMediaTypes } from '../types';
 import { RoomPeer } from './RoomPeer';
 export declare class RoomCalls extends RoomPeer {
     #private;
@@ -18,7 +18,7 @@ export declare class RoomCalls extends RoomPeer {
      * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
      * @param deviceId string
      */
-    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string) => Promise<boolean | Streams>;
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string) => Promise<unknown>;
     /**
      * changeScreenSharing
      * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
@@ -60,38 +60,24 @@ export declare class RoomCalls extends RoomPeer {
      * @example quickvo.checkInRoom()
      */
     checkInRoom: () => Promise<Boolean>;
+    /**
+     * senderActived
+     */
+    senderActived: (timeout: number) => Promise<void>;
     /**
      * 发布流
      * @param mediaTypes MediaType[]
      * @example quickvo.publish(['microphoneCamera_audio', 'microphoneCamera_video'], 3)
-     * @returns Promise<RoomUser>
+     * @returns Promise<boolean>
      */
-    publish: (mediaTypes: K_mediaType[]) => Promise<unknown>;
+    publish: (mediaTypes: K_mediaType[]) => Promise<boolean>;
     /**
      * stopPublish
      * @param trackNames  string[] = []
      * @example quickvo.stopPublish(['microphoneCamera_audio'])
-     * @returns Promise<RoomUser>
-     */
-    stopPublish: (mediaTypes?: K_mediaType[]) => Promise<unknown>;
-    /**
-     * subscribe
-     * @param trackNames strig[]
-     * @param count number
-     * @example quickvo.subscribe(['trackName1','trackName2'])
-     * @returns Promise<RoomUser[]>
-     */
-    subscribe: (trackNames?: string[], count?: number) => Promise<unknown>;
-    /**
-     * renegotiate
-     */
-    renegotiate: () => Promise<unknown>;
-    /**
-     * stopSubscribe
-     * @param trackNames  string[] = []
-     * @example quickvo.subscribe(['trackName1'])
+     * @returns Promise<boolean>
      */
-    stopSubscribe: (trackNames?: string[]) => Promise<unknown>;
+    stopPublish: (mediaTypes?: K_mediaType[]) => Promise<boolean>;
     /**
      * inactiveTracks
      * @param mediaTypes MediaType[]
@@ -99,6 +85,20 @@ export declare class RoomCalls extends RoomPeer {
      * @example quickvo.inactiveTracks(['microphoneCamera_audio'], false)
      */
     inactiveTracks: (mediaTypes: K_mediaType[], enabled: boolean) => Promise<boolean>;
+    /**
+     * subscribe
+     * @param userMediaTypes: UserMediaTypes[] = []
+     * @example quickvo.subscribe([{ userId: '123', mediaTypes: ['mediaTypes', 'microphoneCamera_video'] }])
+     * @returns Promise<boolean>
+     */
+    subscribe: (userMediaTypes?: UserMediaTypes[]) => Promise<unknown>;
+    /**
+     * stopSubscribe
+     * @param userMediaTypes: UserMediaTypes[] = []
+     * @example quickvo.stopSubscribe([{ userId: '123', mediaTypes: ['mediaTypes', 'microphoneCamera_video'] }])
+     * @returns Promise<boolean>
+     */
+    stopSubscribe: (userMediaTypes?: UserMediaTypes[]) => Promise<boolean>;
     /**
      * setBanBehaviors
      */
@@ -107,23 +107,61 @@ export declare class RoomCalls extends RoomPeer {
         banBehaviors: { [key in K_mediaType]?: boolean; };
     }>) => Promise<unknown>;
     /**
-     * pubChannel
+     * debugger
      */
-    pubChannel: () => Promise<Boolean>;
+    debugger: () => Promise<import('..').SendMessageRevolve<any>>;
     /**
-     * subChannel
+     * shutdown
      */
-    subChannel: (userChannels?: any[]) => Promise<Boolean>;
-    debugger: () => Promise<any>;
-    shutdown: () => Promise<any>;
+    shutdown: () => Promise<import('..').SendMessageRevolve<any>>;
     /**
-     * reconstruct
+     * restoreRoom
+     */
+    restoreRoom: () => Promise<void>;
+    /**
+     * restoreICE
+     */
+    restoreICE: () => Promise<void>;
+    /**
+     * initHeartbeat
      */
-    reconstruct: () => Promise<void>;
     initHeartbeat: () => void;
+    /**
+     * stopHeartbeat
+     */
     stopHeartbeat: () => void;
     /**
      * setSession
      */
     setSession: () => void;
+    /**
+     * wsConnected
+     */
+    cwsConnected: () => Promise<unknown>;
+    p2p: {
+        /**
+         * open
+         */
+        open: (remoteUserId: string, mediaTypes?: K_mediaType[]) => Promise<unknown>;
+        /**
+         * replaceSenderStreams
+         */
+        replaceSenderStreams: (remoteUserIds: string[], mediaTypes: K_mediaType[] | undefined, isReal: Boolean) => Promise<void>;
+        /**
+         * reportNetwork
+         */
+        reportNetwork: () => Promise<unknown>;
+        /**
+         * reportP2PConnect
+         */
+        reportP2PConnect: (recvUserId: string, sendUserId: string, state: "success" | "fail" | "ignore" | "disconnect" | "poor_network", reason?: string, pushUserIds?: string[], connectedTime?: number) => Promise<import('..').SendMessageRevolve<any>>;
+        /**
+         * closeSend
+         */
+        closeSend: (userIds?: string[], mediaTypes?: K_mediaType[]) => Promise<void>;
+        /**
+         * closeRecv
+         */
+        closeRecv: (userIds?: string[], mediaTypes?: K_mediaType[]) => Promise<void>;
+    };
 }

package/dist/room/RoomMedias.d.ts

@@ -22,12 +22,12 @@ export declare class RoomMedias extends RoomBase {
      */
     emitNotifyUpdateUsersStreams: (notifys: Array<{
         userId: string;
-        updateStreams: { [key in K_mediaType]?: boolean; };
+        updateStreams: { [key in K_mediaType]?: string; };
     }>) => Promise<void>;
     /**
      * initUserMediaStreamContext
      */
-    initUserMediaStreamContext: (userId: string, mediaType: K_mediaType, stream: MediaStream) => Promise<void>;
+    initUserMediaStreamContext: (userId: string, mediaType: K_mediaType, stream: MediaStream, clear: boolean) => Promise<void>;
     /**
      * getUserMediaStreamContext
      */

package/dist/room/RoomPeer.d.ts

@@ -2,31 +2,27 @@ import { K_callStrategy } from '../enums/callStrategy';
 import { K_mediaType } from '../enums/mediaType';
 import { QuickOptions, UserTrack } from '../types';
 import { RoomUsers } from './RoomUsers';
+import { PeerAnalyzeStats } from './PeerAnalyzeStats';
 export declare class RoomPeer extends RoomUsers {
     #private;
-    getPeerStatsTimer: number;
-    reports: any[];
-    candidates: any[];
-    peerNetwork: {
-        inboundBytes: number;
-        outboundBytes: number;
-        lostRate: string;
-        roundTripTime: string;
-        jitter: string;
-    };
+    peerAnalyzeStatsIns: PeerAnalyzeStats;
+    offset_inboundBytes: number;
+    offset_outboundBytes: number;
     constructor(options: QuickOptions);
     /**
-     * initPeer
-     */
-    initPeer: () => void;
-    /**
-     * initSendChannel
+     * saveBoundBytes
      */
-    initSendChannel: (label: string | undefined, id: number) => void;
+    saveBoundBytes: (type: "superfluous" | "missing") => void;
+    getTrafficUse: () => {
+        sfuPush: number;
+        sfuPull: number;
+        p2pPush: number;
+        p2pPull: number;
+    };
     /**
-     * initReceiveChannel
+     * initPeer
      */
-    initReceiveChannel: (label: string | undefined, id: number) => void;
+    initPeer: () => void;
     /**
      * replaceSenderStream
      */
@@ -34,14 +30,7 @@ export declare class RoomPeer extends RoomUsers {
     /**
      * getSenderTracks
      */
-    getSenderTracks: (mediaTypes?: K_mediaType[]) => Promise<{
-        type: number;
-        enabled: boolean;
-        trackName: string;
-        location: string;
-        mid: string | null;
-        key: string;
-    }[]>;
+    getSenderTracks: (mediaTypes?: K_mediaType[]) => Promise<UserTrack[]>;
     /**
      * addSenders
      */
@@ -51,9 +40,9 @@ export declare class RoomPeer extends RoomUsers {
      */
     removeSenders: (mediaTypes?: K_mediaType[]) => Promise<void>;
     /**
-     * onSubscribeUserTracks
+     * stopSenders
      */
-    onSubscribeUserTracks: (users: any[]) => Promise<unknown>;
+    stopSenders: (mediaTypes?: K_mediaType[]) => void;
     /**
      * iceConnected
      */
@@ -61,7 +50,7 @@ export declare class RoomPeer extends RoomUsers {
     /**
      * closeUserTracks
      */
-    closeUserTracks: (userId: string, closeTracks?: UserTrack[], remove?: boolean) => Promise<void>;
+    stopTransceivers: (mids: string[]) => Promise<void>;
     createOffer: () => Promise<void>;
     createAnswer: () => Promise<void>;
     getSdp: () => string | undefined;
@@ -79,31 +68,33 @@ export declare class RoomPeer extends RoomUsers {
      */
     setRTCRtpSenderParameters: (parameters: RTCRtpSendParameters) => void;
     /**
-     * getReportsByMid
-     */
-    getReportsByMid: (mids?: string[]) => Promise<any[]>;
-    /**
-     * getRoomNetwork
+     * getPeerNetwork
      */
-    getRoomNetwork: () => {
+    getPeerNetwork: () => {
         inboundBytes: number;
         outboundBytes: number;
         lostRate: string;
         roundTripTime: string;
         jitter: string;
+        quality: number;
+        averageQuality: number;
     };
     /**
-     * getPeerNetwork
+     * getRoomNetwork
      */
-    getPeerNetwork: () => {
+    getRoomNetwork: () => {
         inboundBytes: number;
         outboundBytes: number;
         lostRate: string;
         roundTripTime: string;
         jitter: string;
+        quality: number;
+        averageQuality: number;
     };
     /**
-     * stopGetPeerStats
+     * getReportsByMid
      */
+    getReportsByMid: (mids?: string[]) => Promise<any[]>;
+    startGetPeerStats: () => void;
     stopGetPeerStats: () => void;
 }

package/dist/room/RoomUsers.d.ts

@@ -1,9 +1,10 @@
 import { K_mediaType } from '../enums/mediaType';
-import { QuickOptions, RoomUser, UserTrack } from '../types';
+import { QuickOptions, RoomUser, UserMediaTypes, UserTrack, UserTracks } from '../types';
 import { RoomMedias } from './RoomMedias';
+import { P2P } from './P2P';
 export declare class RoomUsers extends RoomMedias {
     constructor(options: QuickOptions);
-    createP2P: () => Promise<void>;
+    getP2PIns: (userId: string) => Promise<P2P | undefined>;
     /**
      * getMaxVolumeUser
      */
@@ -100,9 +101,24 @@ export declare class RoomUsers extends RoomMedias {
      */
     getUserTrackByTrackName: (trackNames: string[]) => Promise<UserTrack[]>;
     /**
-     * getUserTrackFromMid
+     * getUserTrackByMid
      */
-    getUserTrackFromMid: (mid: string) => Promise<UserTrack | undefined>;
+    getUserTrackByMid: (mid: string) => Promise<UserTrack | undefined>;
+    /**
+     * getUsersMediaTypeBytrackNames
+     */
+    getUsersMediaTypeBytrackNames: (trackNames: string[]) => Promise<{
+        userId: string;
+        mediaTypes: ("microphoneCamera_audio" | "microphoneCamera_video" | "screenSharing_video" | "screenSharing_audio")[];
+    }[]>;
+    /**
+     * getUserTrackByUserMediaTypes
+     */
+    getUserTrackByUserMediaTypes: (usersMediaTypes?: UserMediaTypes[], lastRetry?: boolean) => Promise<UserTracks[]>;
+    /**
+     * getAllUserMediaTypes
+     */
+    getAllUserMediaTypes: () => Promise<UserMediaTypes[]>;
     /**
      * checkUserInRoom
      */
@@ -120,10 +136,6 @@ export declare class RoomUsers extends RoomMedias {
      * setUserUpdateStreams
      */
     setUserUpdateStreams: (userId: string, mediaType: K_mediaType, state?: boolean) => Promise<void>;
-    /**
-     * updateUserChannels
-     */
-    updateUserChannels: (userId: string, channels: any[] | undefined, merge: Boolean) => Promise<void>;
     /**
      * updateUsertracks
      */
@@ -147,6 +159,10 @@ export declare class RoomUsers extends RoomMedias {
      * updateUserPermissions
      */
     updateUserPermissions: (userId: string, permissions: number | undefined) => Promise<void>;
+    /**
+     * updateUserUseP2P
+     */
+    updateUserUseP2P: (userId: string, useP2P: boolean) => Promise<void>;
     /**
      * updateUserBase
      */