@vkontakte/calls-sdk 2.8.12-beta.0 → 2.8.12-dev.c0dd153e.0

package/classes/Conversation.d.ts

@@ -12,8 +12,9 @@ import UserType from '../enums/UserType';
 import { JSONObject } from '../static/Json';
 import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
 import { AudienceModeHandsResponse } from '../types/AudienceMode';
-import { ConversationData, ConversationOnJoinParams, ConversationOnStartParams } from '../types/Conversation';
-import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk } from '../types/ExternalId';
+import { ConversationData, ConversationOnStartParams } from '../types/Conversation';
+import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
+import type { FastJoinHandler } from '../types/FastJoin';
 import MediaModifiers from '../types/MediaModifiers';
 import MediaSettings, { IVideoDimentions } from '../types/MediaSettings';
 import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
@@ -84,7 +85,15 @@ export default class Conversation extends EventEmitter {
     static getSyncedTime(): number;
     get debugSessionId(): string | null;
     onStart({ opponentIds, opponentType, mediaOptions, payload, joiningAllowed, requireAuthToJoin, onlyAdminCanShareMovie, externalIds, onFastStart, conversationId, }: ConversationOnStartParams): Promise<ConversationData>;
-    onJoin(joinArgs: ConversationOnJoinParams): Promise<ConversationData>;
+    onJoin(joinArgs: {
+        conversationId?: string;
+        mediaOptions: MediaOption[];
+        chatId?: string;
+        joinLink?: string;
+        observedIds?: ExternalUserId[];
+        payload?: string;
+        onFastJoin?: FastJoinHandler;
+    }): Promise<ConversationData>;
     private _onJoinPart2;
     private _extractExternalRooms;
     private _extractExternalRoomsData;
@@ -97,6 +106,7 @@ export default class Conversation extends EventEmitter {
     private _acceptConcurrent;
     private _getMainRoomParticipants;
     private _decodeExternalConversationParams;
+    private _logCallStartEvent;
     accept(mediaOptions: MediaOption[]): Promise<ConversationData>;
     decline(): Promise<void>;
     hangup(): Promise<void>;
@@ -186,9 +196,6 @@ export default class Conversation extends EventEmitter {
     private _cleanupParticipants;
     private _cleanupParticipantAgnosticStreams;
     private _cleanupTransport;
-    private _finishLifecycle;
-    private _getFirstMediaSentCallback;
-    private _stopFirstMediaSentProbe;
     private _cleanupTransportForHold;
     private _cleanupSpeakerDetector;
     private _cleanupSpecListener;

package/classes/StatsLogger.d.ts

@@ -1,14 +1,6 @@
 import BaseApi from '../abstract/BaseApi';
 import BaseLogger from '../abstract/BaseLogger';
 import StatLog from '../enums/StatLog';
-import TransportTopology from '../enums/TransportTopology';
-type ClientStatsPayload = Record<string, string | number | boolean | undefined | null>;
-export type LogClientStatsOptions = {
-    immediately?: boolean;
-    occurredAt?: number;
-    conversationId?: string | null;
-    deferUntilServerTime?: boolean;
-};
 /**
  * Класс отвечает за отправку различной информации в сервис статистики (события, статистика и подобное)
  */
@@ -16,26 +8,19 @@ export default class StatsLogger extends BaseLogger {
     private readonly _externalLogger;
     private readonly _api;
     private readonly _conversationIdProvider;
-    private readonly _topologyProvider;
     private readonly _batchInterval;
     private _batchedClientStats;
     private _batchTimeout;
     private _serverTimeDelta;
-    private _waitingForServerTime;
-    private _deferredClientStats;
-    constructor(api: BaseApi, externalLogger: BaseLogger | null, conversationIdProvider: () => string | null, topologyProvider?: () => TransportTopology | undefined);
+    constructor(api: BaseApi, externalLogger: BaseLogger | null, conversationIdProvider: () => string | null);
     log(name: StatLog, value?: string, immediately?: boolean): void;
-    logClientStats(data: ClientStatsPayload, immediatelyOrOptions?: boolean | LogClientStatsOptions): void;
+    logClientStats(data: Record<string, string | number | boolean | undefined | null>, immediately?: boolean): void;
     destroy(): void;
-    private _logClientStats;
     private _getConversationId;
-    private _getCallTopology;
     private _sendBatch;
     private _startTimeout;
     private _stopTimeout;
     private _sendClientStats;
     private _calculateServerTimeDelta;
-    private _flushDeferredClientStats;
     private _now;
 }
-export {};

package/classes/stat/ConversationStats.d.ts

@@ -1,22 +1,21 @@
 import BaseApi from '../../abstract/BaseApi';
 import BaseLogger from '../../abstract/BaseLogger';
-import TransportTopology from '../../enums/TransportTopology';
 import HangupReason from '../HangupReason';
 import StatsLogger from '../StatsLogger';
-import { CallLifecycleStats } from './CallLifecycleStats';
+import TransportTopology from '../../enums/TransportTopology';
 import { CodecStatsAggregator } from './CodecStatsAggregator';
 import { StatAggregator } from './StatAggregator';
 import { StatPings } from './StatPings';
 import { StatSignalingCommands } from './StatSignalingCommands';
 export declare class ConversationStats {
     readonly logger: StatsLogger;
-    readonly lifecycle: CallLifecycleStats;
     readonly statAggregator: StatAggregator;
     readonly codecStatsAggregator: CodecStatsAggregator;
     readonly pings: StatPings;
     readonly signalingCommands: StatSignalingCommands;
     constructor(api: BaseApi, externalLogger: BaseLogger | null, getConversationId: () => string | null, getTopology: () => TransportTopology | undefined);
-    logHangup(reason: HangupReason): void;
-    flushCallMetrics(): void;
+    logHangup(reason: HangupReason, topology?: TransportTopology): void;
+    flushCallMetrics(topology?: TransportTopology): void;
     destroy(): void;
+    private static correctHangupReason;
 }

package/classes/stat/StatPings.d.ts

@@ -1,5 +1,6 @@
 import { SignalingTransportType } from '../../enums/SignalingTransportStat';
 import StatsLogger from '../StatsLogger';
+import TransportTopology from '../../enums/TransportTopology';
 export declare class StatPings {
     private readonly _logger;
     private trackerByTransport;
@@ -11,6 +12,6 @@ export declare class StatPings {
      */
     mark(transport: SignalingTransportType): void;
     /** Отправляем данные в стату */
-    logMetrics(): void;
+    logMetrics(topology?: TransportTopology): void;
     destroy(): void;
 }

package/classes/stat/StatSignalingCommands.d.ts

@@ -1,11 +1,12 @@
 import { SignalingTransportType } from '../../enums/SignalingTransportStat';
 import StatsLogger from '../StatsLogger';
+import TransportTopology from '../../enums/TransportTopology';
 export declare class StatSignalingCommands {
     private readonly _logger;
     private trackerByCommand;
     constructor(logger: StatsLogger);
     mark(command: string, time: number, transport: SignalingTransportType): void;
     /** Отправляем данные в стату */
-    logMetrics(): void;
+    logMetrics(topology?: TransportTopology): void;
     destroy(): void;
 }

package/classes/transport/BaseTransport.d.ts

@@ -7,13 +7,7 @@ export default abstract class BaseTransport extends EventEmitter {
     protected readonly _mediaSource: MediaSource;
     protected _state: TransportState;
     protected _pc: RTCPeerConnection | null;
-    private readonly _onFirstMediaSent;
-    private _firstMediaSentProbe;
-    private _firstMediaSentProbeStopped;
-    protected constructor(signaling: BaseSignaling, mediaSource: MediaSource, onFirstMediaSent?: (() => void) | null);
+    protected constructor(signaling: BaseSignaling, mediaSource: MediaSource);
     getState(): TransportState;
-    stopFirstMediaSentProbe(): void;
     abstract close(error?: Error): void;
-    protected _startFirstMediaSentProbe(): void;
-    protected _disposeFirstMediaSentProbe(): void;
 }

package/classes/transport/DirectTransport.d.ts

@@ -43,7 +43,7 @@ export default class DirectTransport extends BaseTransport {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    constructor(participantId: ParticipantId, isMaster: boolean, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
+    constructor(participantId: ParticipantId, isMaster: boolean, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
     get participantId(): ParticipantId;
     updateStatisticsInterval(): void;
     private _isDeadConnection;

package/classes/transport/ServerTransport.d.ts

@@ -47,7 +47,7 @@ export default class ServerTransport extends BaseTransport {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
+    constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
     updateStatisticsInterval(): void;
     open(observer?: boolean): void;
     close(error?: Error): void;

package/classes/transport/Transport.d.ts

@@ -48,16 +48,13 @@ export declare class Transport extends EventEmitter {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    private readonly _onFirstMediaSent;
-    private _firstMediaSentProbeStopped;
-    constructor(topology: TransportTopology, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
+    constructor(topology: TransportTopology, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
     updateSettings(settings: ServerSettings): void;
     updateStatisticsInterval(): void;
     allocate(participantId: ParticipantId, isMaster?: boolean): void;
     open(participantIds: ParticipantId[], peerId?: string | null, observer?: boolean, force?: boolean): void;
     close(participantId: ParticipantId): void;
     destroy(): void;
-    stopFirstMediaSentProbe(): void;
     holdClose(): void;
     setRemoteHold(hold: boolean): void;
     getTopology(): TransportTopology;
@@ -72,8 +69,6 @@ export declare class Transport extends EventEmitter {
     private _setStates;
     private _setLocalState;
     private _onSignalingNotification;
-    private _handleFirstMediaSent;
-    private _getFirstMediaSentCallback;
     private _onTopologyChanged;
     private _createDirectTransport;
     private _createServerTransport;

package/default/Signaling.d.ts

@@ -1,15 +1,15 @@
 import BaseSignaling, { AddParticipantParams } from '../abstract/BaseSignaling';
-import StatsLogger from '../classes/StatsLogger';
 import { ParticipantIdRegistry } from '../classes/ParticipantIdRegistry';
 import { SharingStatReport } from '../classes/screenshare/SharingStatReport';
 import { StatAggregator } from '../classes/stat/StatAggregator';
 import { StatPings } from '../classes/stat/StatPings';
 import { StatSignalingCommands } from '../classes/stat/StatSignalingCommands';
-import TransportTopology from '../enums/TransportTopology';
+import StatsLogger from '../classes/StatsLogger';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
 import SignalingConnectionType from '../enums/SignalingConnectionType';
+import TransportTopology from '../enums/TransportTopology';
 import UserRole from '../enums/UserRole';
 import { type DebugLogger } from '../static/Debug';
 import { JSONObject } from '../static/Json';

package/enums/Stat.d.ts

@@ -1,10 +1,4 @@
 declare const enum Stat {
-    CALL_INIT = "call_init",
-    CALL_WARMUP = "call_warmup",
-    CALL_START = "call_start",
-    CALL_ACCEPTED_OUTGOING = "call_accepted_outgoing",
-    CALL_ACCEPTED_INCOMING = "call_accepted_incoming",
-    FIRST_MEDIA_SENT = "first_media_sent",
     CALL_FINISH = "call_finish",// событие отправляемое в конце звонка
     CODEC_USAGE = "codec_usage",// событие когда меняется кодек
     SIGNALING_CONNECTED = "signaling_connected",// measure
@@ -13,6 +7,7 @@ declare const enum Stat {
     FIRST_MEDIA_RECEIVED = "first_media_received",
     CALL_DECLINED_OR_HANGED_LOCALLY = "CallDeclinedOrHangedLocally",
     USER_FEEDBACK_RECEIVED = "UserFeedbackReceived",
+    CALL_START = "call_start",
     SIGNALING_PING_SUMMARY = "signaling_ping_summary",
     SIGNALING_COMMAND_SUMMARY = "signaling_command_summary",
     WEBSOCKET_CONNECTED = "websocket_connected",

package/package.json

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

package/types/Conversation.d.ts

@@ -7,8 +7,7 @@ import MediaOption from '../enums/MediaOption';
 import UserRole from '../enums/UserRole';
 import { AsrInfo } from './Asr';
 import { IFeaturesPerRole } from './ConversationFeature';
-import { ExternalId, ExternalParticipantId, ExternalUserId } from './ExternalId';
-import { FastJoinHandler } from './FastJoin';
+import { ExternalId, ExternalParticipantId } from './ExternalId';
 import { FastStartHandler } from './FastStart';
 import MediaModifiers from './MediaModifiers';
 import MuteStates from './MuteStates';
@@ -85,16 +84,6 @@ export type ConversationOnStartParams = {
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };
-export type ConversationOnJoinParams = {
-    conversationId?: string;
-    mediaOptions: MediaOption[];
-    chatId?: string;
-    joinLink?: string;
-    observedIds?: ExternalUserId[];
-    payload?: string;
-    onFastJoin?: FastJoinHandler;
-    anonymous?: boolean;
-};
 export type StartConversationParams = {
     opponentIds?: OkUserId[];
     opponentType: CallType;
@@ -105,6 +94,7 @@ export type StartConversationParams = {
     requireAuthToJoin?: boolean;
     onlyAdminCanShareMovie?: boolean;
     externalIds?: ExternalId[];
+    startedTime: number;
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };

package/types/WebTransport.d.ts

@@ -1,33 +1,32 @@
 import { WebTransportOptions } from '@fails-components/webtransport';
 import { DebugLogger } from '../static/Debug';
 declare class WebTransportEventual {
+    static isBrowserSupported(): boolean;
+    onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
+    onmessage: ((this: WebTransportEventual, ev: MessageEvent) => any) | null;
+    onerror: ((this: WebTransportEventual, ev: Event) => any) | null;
+    onclose: ((this: WebTransportEventual, ev: CloseEvent) => any) | null;
+    readyState: number;
     private webTransport;
-    private stream;
     private writer;
-    private reader;
     private readonly url;
     private readonly options;
     private readonly compression;
-    private closeRequested;
-    private closeEventEmitted;
     private encoder;
     private decoder;
     private readonly _debug;
-    onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
-    onmessage: ((this: WebTransportEventual, ev: MessageEvent) => any) | null;
-    onerror: ((this: WebTransportEventual, ev: Event) => any) | null;
-    onclose: ((this: WebTransportEventual, ev: CloseEvent) => any) | null;
-    readyState: number;
     constructor(url: string, options?: WebTransportOptions, debug?: DebugLogger);
+    send(data: string): Promise<void>;
+    close(code?: number, reason?: string): void;
     private getCompressionTypeFromUrl;
     private connect;
-    private readChunks;
+    private observeClosed;
     private readLoop;
-    send(data: string): Promise<void>;
+    private fail;
+    private handleStreamError;
+    private requestNativeClose;
+    private finishClose;
+    private emitEvent;
     private createErrorEvent;
-    close(code?: number, reason?: string): void;
-    private closeConnectedTransport;
-    private emitClose;
-    static isBrowserSupported(): boolean;
 }
 export { WebTransportEventual as WebTransport };

package/classes/stat/CallLifecycleStats.d.ts

@@ -1,47 +0,0 @@
-import HangupReason from '../HangupReason';
-import StatsLogger from '../StatsLogger';
-export type CallLifecycleSource = 'outgoing' | 'incoming' | 'join' | 'anonym_join';
-export interface CallLifecycleInitializationParams {
-    source: CallLifecycleSource;
-    conversationId?: string;
-}
-export interface CallLifecycleClock {
-    wallNow(): number;
-    monotonicNow(): number;
-}
-export declare class CallLifecycleStats {
-    private readonly _logger;
-    private readonly _clock;
-    private _conversationId;
-    private _callStartLabel;
-    private _lifecycleStartedAtMonotonic;
-    private _warmupStartedAtMonotonic;
-    private _pendingEvents;
-    private _warmupCompleted;
-    private _callStarted;
-    private _accepted;
-    private _firstMediaSent;
-    private _finished;
-    private _destroyed;
-    constructor(logger: StatsLogger, clock?: CallLifecycleClock);
-    get firstMediaSentReported(): boolean;
-    get terminated(): boolean;
-    markInitializationStarted({ source, conversationId }: CallLifecycleInitializationParams): void;
-    bindConversationId(conversationId: string): void;
-    markWarmupStarted(): void;
-    markWarmupCompleted(): void;
-    markCallStarted(): void;
-    markOutgoingAccepted(): void;
-    markIncomingAccepted(concurrent: boolean): void;
-    markFirstMediaSent(): void;
-    markFinished(reason: HangupReason): void;
-    markTerminated(): void;
-    destroy(): void;
-    private _canRecord;
-    private _durationSince;
-    private _finish;
-    private _ensureConversationId;
-    private _record;
-    private _flushPendingEvents;
-    private _logEvent;
-}

package/classes/stat/FirstMediaSentProbe.d.ts

@@ -1,13 +0,0 @@
-export declare class FirstMediaSentProbe {
-    private readonly _peerConnection;
-    private readonly _onFirstMediaSent;
-    private readonly _pollIntervalMs;
-    private _timer;
-    private _state;
-    constructor(peerConnection: RTCPeerConnection, onFirstMediaSent: () => void, pollIntervalMs?: number);
-    start(): void;
-    destroy(): void;
-    private _getStatsReports;
-    private _poll;
-    private _scheduleNextPoll;
-}