@vkontakte/calls-sdk 2.8.11-dev.e80e239d.0 → 2.8.11-dev.f092dc48.0

package/classes/AudioFix.d.ts

@@ -15,10 +15,12 @@ export default class AudioFix {
     private _lastPacketsSentTime;
     private _toggleAudioPromise;
     private _fixNoPacketsAppliedVideo;
+    private _disabled;
     constructor(mediaSource: MediaSource, debug?: DebugLogger, logger?: StatsLogger | null);
     private _fixAudioDeviceNoPackets;
     private _fixAudioDeviceTooManyPackets;
     fix(rtps: any[]): void;
     /** важно вызывать ___после___ метода `fix()` */
     fixVideo(rtps: any[]): void;
+    disable(): void;
 }

package/classes/CallRegistry.d.ts

@@ -1,7 +1,8 @@
 import Conversation from './Conversation';
+import MediaSettings from '../types/MediaSettings';
 export interface HoldableConversation extends Conversation {
     id: string;
-    hold(hold: boolean): Promise<void>;
+    hold(hold: boolean, lastActiveMediaSettings?: MediaSettings): Promise<void>;
 }
 export declare class CallRegistry {
     private _conversations;
@@ -11,11 +12,14 @@ export declare class CallRegistry {
     remove(id: string | null): void;
     get(id: string): HoldableConversation | undefined;
     getActive(): HoldableConversation | null;
+    getFirstHeld(): HoldableConversation | null;
     getActiveId(): string | null;
     has(id: string): boolean;
     getAll(): HoldableConversation[];
     get callsLength(): number;
     setActive(id: string): Promise<void>;
+    setHold(id: string): Promise<void>;
+    switchCall(id: string): Promise<void>;
     clear(): void;
 }
 declare const callRegistry: CallRegistry;

package/classes/Conversation.d.ts

@@ -38,6 +38,8 @@ export default class Conversation extends EventEmitter {
     private _myLastRequestedLayouts;
     private _state;
     private _previousState;
+    /** Если пользователь в зале ожидания, холд должен вызываться после промоута */
+    private _waitingHallHoldPending;
     private _participantState;
     private _participants;
     private _pendingParticipants;
@@ -209,7 +211,13 @@ export default class Conversation extends EventEmitter {
      */
     changePriorities(priorities: ParticipantPriority[]): Promise<void>;
     changeParticipantState(state: ParticipantStateData, compositeUserId?: CompositeUserId): Promise<void>;
-    hold(hold: boolean): Promise<void>;
+    hold(hold: boolean, lastActiveMediaSettings?: MediaSettings): Promise<void>;
+    private _holdLocally;
+    private _resumeLocalMedia;
+    private _setOutgoingAudioEnabled;
+    private _restoreStateAfterHold;
+    private _isWaitingForPromotion;
+    private _getWaitingForPromotionStatus;
     putHandsDown(): Promise<void>;
     requestKeyFrame(participantStreamDescription: ParticipantStreamDescription): Promise<void | SignalingMessage>;
     requestTestMode(consumerCommand: string, producerCommand: string): Promise<void>;

package/classes/ConversationResponseValidator.d.ts

@@ -0,0 +1,3 @@
+import ConversationResponse from '../types/ConversationResponse';
+export type ConversationResponseSource = 'startConversation' | 'joinConversation' | 'joinConversationByLink' | 'fastStart' | 'fastJoin';
+export declare function assertValidConversationResponse(response: ConversationResponse | null | undefined, source: ConversationResponseSource): void;

package/classes/MediaSource.d.ts

@@ -101,7 +101,7 @@ export declare class MediaSource extends EventEmitter {
     private _stopEffect;
     destroy(): void;
     stopLocalMedia(): Promise<void>;
-    resumeLocalMedia(): Promise<void>;
+    resumeLocalMedia(lastActiveMediaSettings?: MediaSettings): Promise<void>;
     toggleScreenCapturing(settings: ScreenCaptureSettings): Promise<void>;
     disableScreenCapturing(): Promise<void>;
     private videoTrackMuteHandler;

package/classes/stat/StatFirstMediaReceived.d.ts

@@ -4,6 +4,7 @@ import { StatAggregator } from './StatAggregator';
 declare enum ECallType {
     DirectOutgoing = "direct_outgoing",
     DirectIncoming = "direct_incoming",
+    DirectJoin = "direct_join",
     ServerIncoming = "server_incoming",
     ServerJoinServer = "server_join_server",
     ServerChangeTopology = "server_change_topology"
@@ -17,8 +18,8 @@ export declare class StatFirstMediaReceived {
     constructor(statAggregator: StatAggregator);
     markAcceptCall(topology: TransportTopology): void;
     markAcceptedCall(topology?: TransportTopology): void;
-    markParticipantJoined(topology: TransportTopology): void;
     markOnJoin(topology: TransportTopology): void;
+    markTopologyChanged(topology: TransportTopology): void;
     private mark;
     measure(): void;
 }

package/classes/transport/DirectTransport.d.ts

@@ -32,6 +32,8 @@ export default class DirectTransport extends BaseTransport {
     private _neverConnected;
     private _serverSettings;
     private _prevConsumerSettings;
+    private _heldAudioSender;
+    private _heldAudioTrack;
     private _networkLimitsForVideo;
     private _videoMaxDimensionsForNet;
     private _lastVideoMaxDimension;
@@ -50,6 +52,7 @@ export default class DirectTransport extends BaseTransport {
     updateSettings(settings: ServerSettings): void;
     preventRestart(): void;
     allowRestart(): void;
+    setOutgoingAudioEnabled(enabled: boolean): void;
     setAnimojiTransport(receiver: AnimojiReceiver, sender: AnimojiSender): void;
     close(error?: Error): void;
     private _setState;

package/classes/transport/ServerTransport.d.ts

@@ -43,6 +43,8 @@ export default class ServerTransport extends BaseTransport {
     private _producerSessionId;
     private _newAudioShareTrack;
     private _simulcastInfo;
+    private _heldAudioSender;
+    private _heldAudioTrack;
     private readonly _debug;
     private readonly _logger;
     private readonly _statAggregator;
@@ -52,6 +54,7 @@ export default class ServerTransport extends BaseTransport {
     open(observer?: boolean): void;
     close(error?: Error): void;
     removeParticipant(participantId: ParticipantId): void;
+    setOutgoingAudioEnabled(enabled: boolean): void;
     preventRestart(): void;
     allowRestart(): void;
     updateSettings(settings: ServerSettings): void;

package/classes/transport/Transport.d.ts

@@ -55,6 +55,7 @@ export declare class Transport extends EventEmitter {
     open(participantIds: ParticipantId[], peerId?: string | null, observer?: boolean, force?: boolean): void;
     close(participantId: ParticipantId): void;
     destroy(): void;
+    setOutgoingAudioEnabled(enabled: boolean): void;
     getTopology(): TransportTopology;
     isAllocated(participantId: ParticipantId): boolean;
     allocated(): string[];

package/default/Signaling.d.ts

@@ -9,7 +9,6 @@ import TransportTopology from '../enums/TransportTopology';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
-import SignalingCommandType from '../enums/SignalingCommandType';
 import SignalingConnectionType from '../enums/SignalingConnectionType';
 import UserRole from '../enums/UserRole';
 import { type DebugLogger } from '../static/Debug';
@@ -26,29 +25,24 @@ import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/Partici
 import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
 import { StreamDescriptionString } from '../types/ParticipantStreamDescription';
 import { PerfStatReport } from '../types/PerfStatReporter';
-import SignalingMessage, { GetParticipantsSignalingResponse, GetRoomsSignalingResponse, SignalingSuccessResponse } from '../types/SignalingMessage';
+import SignalingMessage, { GetParticipantsSignalingResponse, GetRoomsSignalingResponse } from '../types/SignalingMessage';
 import { IPublishStreamData, IStartStreamData, IStopStreamData } from '../types/Streams';
 export default class Signaling extends BaseSignaling {
-    private socket;
-    protected sequence: number;
+    private transport;
+    private sequence;
     private lastStamp;
     private websocketCommandsQueue;
     private datachannelCommandsQueue;
     private incomingCache;
     private responseHandlers;
     private connectionType;
-    private reconnectCount;
-    private endpoint;
-    private wtEndpoint;
-    protected conversationResolve: Function | null;
-    protected conversationReject: Function | null;
+    private conversationResolve;
+    private conversationReject;
     private connected;
     private listenersReady;
-    protected peerId: number | null;
-    protected conversationId: string | null;
-    private reconnectTimer;
+    private peerId;
+    private conversationId;
     private connectionMessageWaitTimer;
-    private doctorTimer;
     private participantIdRegistry;
     private producerNotificationDataChannel;
     private producerCommandDataChannel;
@@ -57,16 +51,13 @@ export default class Signaling extends BaseSignaling {
     private readonly _debug;
     private readonly _logger;
     private readonly _statAggregator;
-    private readonly _pings;
-    private readonly _signalingCommands;
-    private static get RECONNECT_DELAY();
-    private static get RECONNECT_MAX_DELAY();
-    private static get RECONNECT_MAX_COUNT();
+    private readonly _statPings;
+    private readonly _statSignalingCommands;
     private static get WAIT_CONNECTION_DELAY();
     private static get WAIT_RESPONSE_DELAY();
-    private static get WAIT_MESSAGE_DELAY();
-    constructor(debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, pings?: StatPings | null, signalingCommands?: StatSignalingCommands | null);
     get ready(): boolean;
+    constructor(debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, statPings?: StatPings | null, statSignalingCommands?: StatSignalingCommands | null);
+    setAbortSignal(signal: AbortSignal | undefined): void;
     setEndpoint(endpoint: string): void;
     setWebTransportEndpoint(endpoint: string | null): void;
     setConversationId(conversationId: string): void;
@@ -82,15 +73,6 @@ export default class Signaling extends BaseSignaling {
      * Open a connection with a signaling server
      */
     connect(connectionType: SignalingConnectionType): Promise<SignalingMessage.Connection>;
-    /**
-     * Send a command to a signaling server
-     */
-    protected _send<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
-    /**
-     * Send a raw command to a signaling server
-     */
-    protected _sendRaw<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
-    private _isDataChannelCommand;
     getNextCommandSequenceNumber(): number;
     hangup(reason: string): Promise<SignalingMessage | void>;
     sendCandidate(participantId: ParticipantId, candidate: RTCIceCandidate): Promise<SignalingMessage>;
@@ -173,34 +155,36 @@ export default class Signaling extends BaseSignaling {
     startAsr(params: IAsrStartParams): Promise<SignalingMessage>;
     stopAsr(params?: IAsrStopParams): Promise<SignalingMessage>;
     requestAsr(request: boolean): Promise<SignalingMessage>;
-    private _buildUrl;
-    protected _connect(connectionType: SignalingConnectionType, useWebTransport: boolean): void;
-    protected _disconnect(code?: number): void;
+    /**
+     * Send a command to a signaling server
+     */
+    private _send;
+    /**
+     * Send a raw command to a signaling server
+     */
+    private _sendRaw;
+    private _isDataChannelCommand;
     private _onOpen;
     private _onMessage;
-    protected _handleMessage(message: SignalingMessage): void;
+    private _handleMessage;
     private _handleErrorMessage;
-    protected _handleCachedMessages(): void;
+    private _handleCachedMessages;
     private _throwError;
     private _onError;
     private _serializeErrorEvent;
-    protected _onClose(event: CloseEvent): void;
-    protected _closeSocket(error?: Error | null): void;
-    protected _reconnect(): void;
+    private _onClose;
+    private _closeSocket;
     private _handleCommandResponse;
     private _handleCommandsQueue;
     private _startResponseTimer;
     private _serializeBinary;
     private _serializeJson;
     private _convertDisplayLayout;
-    protected _waitConnectionMessage(): void;
-    protected _stopWaitConnectionMessage(): void;
-    /**
-     * Отвечает за timeout логику в WebSocket, если неполучаем никаких сообщений в течении WAIT_MESSAGE_DELAY, то запускаем реконнект
-     */
-    private _startDoctor;
-    private _stopDoctor;
-    private isWebTransportAvailable;
+    private _waitConnectionMessage;
+    private _stopWaitConnectionMessage;
+    private _onTransportFailed;
+    private _onTransportReconnectScheduled;
+    private _onTransportConnectionDead;
     private _getSocketType;
     private _markTransportStat;
     private _logTransportStat;

package/default/SignalingTransport.d.ts

@@ -0,0 +1,68 @@
+import SignalingConnectionType from '../enums/SignalingConnectionType';
+import { SignalingTransportType } from '../enums/SignalingTransportStat';
+export declare enum SignalingTransportFailure {
+    EMPTY_ENDPOINT = "EMPTY_ENDPOINT",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    ABORTED = "ABORTED"
+}
+export type SignalingTransportFailedEvent = {
+    failure: SignalingTransportFailure;
+    message: string;
+    remote?: boolean;
+};
+export type SignalingTransportReconnectEvent = {
+    count: number;
+    delay: number;
+};
+export type SignalingTransportHandlers = {
+    onOpen: () => void;
+    onMessage: (event: MessageEvent) => void;
+    onError: (event: Event) => void;
+    onClose: (event: CloseEvent) => void;
+    onFailed: (event: SignalingTransportFailedEvent) => void;
+    onReconnectScheduled: (event: SignalingTransportReconnectEvent) => void;
+    onConnectionDead: () => void;
+};
+export default class SignalingTransport {
+    private readonly handlers;
+    private socket;
+    private endpoint;
+    private wtEndpoint;
+    private peerId;
+    private lastStamp;
+    private connectionType;
+    private reconnectCount;
+    private reconnectTimer;
+    private doctorTimer;
+    private forceWebSocket;
+    private abortSignal;
+    private manualClose;
+    private currentType;
+    constructor(handlers: SignalingTransportHandlers);
+    get readyState(): number | null;
+    get type(): SignalingTransportType;
+    setEndpoint(endpoint: string): void;
+    setWebTransportEndpoint(endpoint: string | null): void;
+    setPeerId(peerId: number | null): void;
+    setLastStamp(lastStamp: number): void;
+    setAbortSignal(signal?: AbortSignal): void;
+    resetReconnectCount(): void;
+    connect(connectionType: SignalingConnectionType): void;
+    close(code?: number): void;
+    send(data: string | ArrayBuffer): void;
+    private _connect;
+    private _connectWebTransport;
+    private _connectWebSocket;
+    private _setSocketHandlers;
+    private _buildUrl;
+    private _canUseWebTransport;
+    private _onOpen;
+    private _onMessage;
+    private _onError;
+    private _onClose;
+    private _disconnect;
+    private _scheduleReconnect;
+    private _getReconnectDelay;
+    private _startDoctor;
+    private _stopDoctor;
+}

package/enums/HangupType.d.ts

@@ -53,6 +53,7 @@ declare enum HangupType {
      * - Приложение вызываемого не запущено или упало
      * - Брандмауэр или сетевые ограничения блокируют подключение
      */
-    CALL_TIMEOUT = "CALL_TIMEOUT"
+    CALL_TIMEOUT = "CALL_TIMEOUT",
+    OBSOLETE_CLIENT = "OBSOLETE_CLIENT"
 }
 export default HangupType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/calls-sdk",
-  "version": "2.8.11-dev.e80e239d.0",
+  "version": "2.8.11-dev.f092dc48.0",
   "author": "vk.com",
   "description": "Library for video calls based on the vk.com platform",
   "homepage": "https://vk.com",

package/types/SignalingMessage.d.ts

@@ -97,6 +97,7 @@ declare namespace SignalingMessage {
         markers?: ParticipantListMarkers;
         observedIds?: CompositeUserId[];
         movieShareInfos?: ISharedMovieInfo[];
+        onHold?: boolean;
     }
     export interface ParticipantListChunk extends Notification {
         participants: (Participant & Required<Pick<Participant, 'markers'>>)[];
@@ -190,6 +191,7 @@ declare namespace SignalingMessage {
         deviceIdx?: number;
         peerId: PeerId;
         reason: HangupType;
+        errorCode?: string;
         markers?: ParticipantListMarkers;
     }
     export interface ClosedConversation extends Notification {

package/types/WebTransport.d.ts

@@ -7,6 +7,8 @@ declare class WebTransportEventual {
     private readonly url;
     private readonly options;
     private readonly compression;
+    private closeRequested;
+    private closeEventEmitted;
     private encoder;
     private decoder;
     onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
@@ -22,6 +24,8 @@ declare class WebTransportEventual {
     send(data: string): Promise<void>;
     private createErrorEvent;
     close(code?: number, reason?: string): void;
+    private closeConnectedTransport;
+    private emitClose;
     static isBrowserSupported(): boolean;
 }
 export { WebTransportEventual as WebTransport };