@vkontakte/media-streaming 1.0.1-dev.e965d10.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/media-streaming",
-  "version": "1.0.1-dev.e965d10.0",
+  "version": "1.0.1",
   "author": "vk.com",
   "description": "VK WebRTC media streaming module",
   "homepage": "https://vk.com",

package/types/MediaConstraints.d.ts

@@ -1,5 +1,5 @@
-import type { IMediaConstraints, MediaConstraintsConfig } from "./types";
-export declare class MediaConstraints implements IMediaConstraints {
+import type { MediaConstraintsConfig } from "./types";
+export declare class MediaConstraints {
 	protected readonly config: MediaConstraintsConfig;
 	audio: boolean | MediaTrackConstraints;
 	video: boolean | MediaTrackConstraints;

package/types/MediaError.d.ts

@@ -1,4 +1,4 @@
 import type { MediaErrorType } from "./constants";
-export declare class MediaError extends Error {
+export declare class StreamerMediaError extends Error {
 	constructor(name: string, message: MediaErrorType);
 }

package/types/WebRTCStreamer.d.ts

@@ -1,25 +1,22 @@
 import type { ScreenShareConfig, WebRTCStreamerConfig } from "./types";
 export declare class WebRTCStreamer {
+	#private;
 	private readonly config;
-	private messagesQueue;
-	private ws;
-	private peerConnection;
-	private stream;
-	private screenShareTrack;
-	private connected;
-	private destroying;
-	private cameraId;
-	private microphoneId;
-	private muted;
 	private static notDestroying;
 	constructor(config: WebRTCStreamerConfig);
 	private callback;
+	get connected(): boolean;
 	init(): Promise<void>;
 	connect(): Promise<void>;
 	switchCamera(deviceId: string): Promise<void>;
 	switchMicrophone(deviceId: string): Promise<void>;
 	enableScreenShare(config: ScreenShareConfig): Promise<void>;
 	disableScreenShare(cameraDeviceId?: string): Promise<void>;
+	switchMediaDevices({ cameraId, microphoneId, screenShare }: {
+		cameraId?: string | false;
+		microphoneId?: string | false;
+		screenShare?: ScreenShareConfig | false;
+	}): Promise<void>;
 	setMicMuted(muted: boolean): void;
 	setCameraEnabled(enabled: boolean): void;
 	destroy(): void;
@@ -38,6 +35,7 @@ export declare class WebRTCStreamer {
 	private handleInviteMessage;
 	private handleAnswer;
 	private handleCandidate;
+	private handleScreenShareConstraintsError;
 	private handleError;
 	private createPeerConnection;
 	private readonly handleRTCIceCandidate;
@@ -48,4 +46,5 @@ export declare class WebRTCStreamer {
 	private closeWSConnection;
 	private parseMessage;
 	private tracerLog;
+	private logStat;
 }

package/types/index.d.ts

@@ -1,4 +1,12 @@
+import type { MediaConstraintsConfig } from "./types";
 export { VERSION } from "./env";
-export type { IMediaConstraints, ScreenShareConfig, WebRTCStreamerConfig, WebRTCStreamerCallbacks } from "./types";
-export { MediaErrorType, StreamerError } from "./constants";
+export type { MediaConstraintsConfig, ScreenShareConfig, StatisticsData, IStatisticsLogger, WebRTCStreamerConfig, WebRTCStreamerCallbacks } from "./types";
+export { MediaErrorType, StreamerError, PermissionName } from "./constants";
+export declare const MediaUtils: {
+	enumerateDevices: () => Promise<{
+		cameras: MediaDeviceInfo[];
+		microphones: MediaDeviceInfo[];
+	}>;
+	getUserStream: (config: MediaConstraintsConfig) => Promise<MediaStream>;
+};
 export { WebRTCStreamer } from "./WebRTCStreamer";

package/types/types.d.ts

@@ -1,5 +1,6 @@
 import type { ITracer } from "@vkontakte/videoplayer-shared";
 import type { PermissionName, StreamerError } from "./constants";
+import type { StreamerMediaError } from "./MediaError";
 export type SafeAny = any;
 export type RTCMessageType = "INVITE" | "STATUS" | "BYE" | "ERROR" | "EMPTY";
 export type RTCMessageInviteType = "OFFER" | "CANDIDATE" | "ANSWER" | "BYE";
@@ -37,30 +38,34 @@ export interface ScreenConstraintsConfig {
 	height: number;
 	frameRate?: number;
 }
-export interface IMediaConstraints {
-	audio: boolean | MediaTrackConstraints;
-	video: boolean | MediaTrackConstraints;
-	getNative(): MediaStreamConstraints;
-}
 export interface WebRTCStreamerCallbacks {
+	onConnecting?: VoidFunction;
 	onConnected?: VoidFunction;
-	onDisconnected?: (event: CloseEvent) => void;
+	onDisconnected?: (err?: StreamerError) => void;
 	onError?: (err: StreamerError, reason?: string) => void;
-	onPermissionFailed?: (permissionName: PermissionName, err?: MediaError) => void;
+	onPermissionFailed?: (permissionName: PermissionName, err?: StreamerMediaError) => void;
 	onStreamChanged?: (stream: MediaStream | undefined) => void;
 }
 export type CallbackArgs<N extends keyof WebRTCStreamerCallbacks> = Parameters<NonNullable<WebRTCStreamerCallbacks[N]>>;
 export type ScreenShareConfig = ScreenConstraintsConfig & {
 	onEnded?: VoidFunction;
 };
+type StatDataValue = number | string;
+type StatDataArrValue = StatDataValue[];
+export type StatisticsData = StatDataValue | StatDataArrValue | Record<string, StatDataValue | StatDataArrValue>;
+export interface IStatisticsLogger {
+	log: (event: string, data: StatisticsData) => void;
+}
 export interface WebRTCStreamerConfig {
 	streamKey: string;
 	callbacks: WebRTCStreamerCallbacks;
 	audioOnly?: boolean;
 	lockOrientation?: boolean;
-	mediaConstraints?: IMediaConstraints;
+	mediaConfig?: MediaConstraintsConfig;
 	screenShare?: ScreenShareConfig;
 	serverUrl?: string;
 	stunServers?: RTCIceServer[];
+	statisticsLogger?: IStatisticsLogger;
 	tracer?: ITracer;
 }
+export {};

package/types/utils.d.ts

@@ -1,4 +1,4 @@
-import type { SafeAny } from "./types";
+import type { MediaConstraintsConfig, SafeAny } from "./types";
 import type { ScreenConstraints } from "./ScreenConstraints";
 import type { WebRTCStreamerConfig } from "./types";
 /**
@@ -10,8 +10,11 @@ import type { WebRTCStreamerConfig } from "./types";
 * @returns номер major-версии Safari или undefined
 */
 export declare const getSafariVersion: (userAgent?: string) => number | undefined;
-export declare const enumerateDevices: () => Promise<MediaDeviceInfo[]>;
-export declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+export declare const enumerateDevices: () => Promise<{
+	cameras: MediaDeviceInfo[];
+	microphones: MediaDeviceInfo[];
+}>;
+export declare const getUserStream: (config: MediaConstraintsConfig) => Promise<MediaStream>;
 export declare const getDisplayMedia: (constraints: ScreenConstraints) => Promise<MediaStream>;
 export declare const omitKeys: <T extends Record<string, SafeAny>>(data: T, keys: (keyof T)[]) => Record<string, SafeAny>;
 export declare const serializeStream: (stream: MediaStream) => Record<string, SafeAny>;