@voicenter-team/opensips-js 1.0.124 → 1.0.125

package/dist/index.d.ts

@@ -185,12 +185,68 @@ declare class AudioModule {
     private stopVUMeter;
     setupStream(): Promise<void>;
     private triggerAddStream;
-    initCall(target: string, addToCurrentRoom: boolean, holdOtherCalls?: boolean): void;
+    initCall(target: string, addToCurrentRoom: boolean): void;
     private processRoomChange;
 }
 
 declare type AudioModuleName = typeof MODULES.AUDIO
 
+export declare class BaseNewStreamPlugin extends BasePlugin {
+    private _candidates;
+    private _subscribeSent;
+    private _configureSent;
+    private _lastTrickleReceived;
+    private _publisherSubscribeSent;
+    private opaqueId;
+    protected handleId: number;
+    private readonly type;
+    protected _connection: RTCPeerConnection;
+    protected jsep_offer: RTCSessionDescription | void;
+    protected _request: unknown;
+    stream: MediaStream;
+    constructor(name: any, type: any);
+    connect(options?: ConnectOptions): void;
+    getStream(): MediaStream;
+    getConnection(): RTCPeerConnection;
+    private _createRTCConnection;
+    private addTracks;
+    private _sendInitialRequest;
+    private _receiveInviteResponse;
+    private _sendConfigureMessage;
+    private _sendDetach;
+    protected stopMedia(): Promise<void>;
+    stop(): Promise<void>;
+    generateStream(): Promise<void>;
+}
+
+declare class BasePlugin {
+    opensips: any;
+    session: any;
+    name: string;
+    constructor(name: any);
+    setOpensips(opensips: any): void;
+    setSession(session: any): void;
+    kill(): void;
+}
+
+export declare class BaseProcessStreamPlugin extends BasePlugin {
+    stream: any;
+    running: boolean;
+    immediate: boolean;
+    type: string;
+    constructor(name: any, type: any, options?: BaseProcessStreamPluginOptions);
+    start(stream: any): any;
+    stop(): void;
+    process(stream: any): Promise<any>;
+    connect(): Promise<void>;
+    terminate(): void;
+    kill(): Promise<void>;
+}
+
+declare interface BaseProcessStreamPluginOptions {
+    immediate?: boolean;
+}
+
 declare type CallAddingProgressListener = (callId: string | undefined) => void
 
 declare interface CallOptionsExtended extends AnswerOptionsExtended {
@@ -233,8 +289,6 @@ declare type changeIsDNDListener = (value: boolean) => void
 
 declare type changeIsMutedListener = (value: boolean) => void
 
-declare type changeMainVideoStreamListener = (event: { name: string, event: MediaStream }) => void
-
 declare type changeMuteWhenJoinListener = (value: boolean) => void
 
 declare type changeVideoStateListener = (state: boolean) => void
@@ -246,10 +300,27 @@ declare type ChangeVolumeEventType = {
 
 declare type CommonLogMethodType = (...args: unknown[]) => void
 
+declare type conferenceEndListener = (sessionId) => void
+
 declare type conferenceStartListener = () => void
 
+declare const CONFERENCING_MODE: {
+    WHITEBOARD: string;
+    IMAGE_WHITEBOARD: string;
+};
+
+declare type ConferencingModeType = typeof CONFERENCING_MODE[keyof typeof CONFERENCING_MODE];
+
 declare type connectionListener = (value: boolean) => void
 
+declare interface ConnectOptions {
+    extraHeaders?: Array<string>;
+    fromUserName?: string;
+    fromDisplayName?: string;
+    rtcConstraints?: object;
+    pcConfig?: object;
+}
+
 declare interface CustomLoggerType {
     log: CommonLogMethodType
     warn: CommonLogMethodType
@@ -301,7 +372,7 @@ declare interface IncomingMSRPSessionEvent {
 
 declare type IncomingMSRPSessionListener = (event: IncomingMSRPSessionEvent) => void;
 
-declare type IOpenSIPSConfiguration = Omit<UAConfiguration, 'sockets'>
+declare type IOpenSIPSConfiguration = Omit<UAConfigurationExtended, 'sockets'>
 
 declare interface IOpenSIPSJSOptions {
     configuration: IOpenSIPSConfiguration
@@ -372,6 +443,12 @@ declare interface JanusSessionEventMap {
     'peerconnection:setremotedescriptionfailed': Listener_2;
 }
 
+declare type KonvaDrawerOptions = {
+    strokeWidth?: number
+    strokeColor?: string
+    emptyDrawerRectColor?: string
+}
+
 declare type Listener = (event: unknown) => void
 
 declare type Listener_2 = (event: unknown) => void
@@ -384,6 +461,8 @@ declare type ListenerEventType = EndEvent | IncomingEvent | OutgoingEvent | Inco
 
 declare type ListenersKeyType = keyof OpenSIPSEventMap
 
+declare type MaskEffectTypeConfigType = 'bokehEffect' | 'backgroundImageEffect';
+
 declare type memberHangupListener = (event: object) => void
 
 declare type memberJoinListener = (event: object) => void
@@ -660,7 +739,11 @@ declare interface OpenSIPSEventMap extends UAEventMap {
     newMSRPSession: MSRPSessionListener
     // JANUS
     conferenceStart: conferenceStartListener
-    changeMainVideoStream: changeMainVideoStreamListener
+    conferenceEnd: conferenceEndListener
+    startScreenShare: startScreenShareListener
+    stopScreenShare: stopScreenShareListener
+    startBlur: startBlurListener
+    stopBlur: stopBlurListener
     memberJoin: memberJoinListener
     memberHangup: memberHangupListener
     changeAudioState: changeAudioStateListener
@@ -680,6 +763,7 @@ declare class OpenSIPSJS extends UAExtended {
     private readonly newMSRPSessionEventName;
     private isMSRPInitializingValue;
     private isReconnecting;
+    private activeConnection;
     audio: AudioModule;
     msrp: MSRPModule;
     video: VideoModule;
@@ -690,7 +774,10 @@ declare class OpenSIPSJS extends UAExtended {
     off<T extends ListenersKeyType>(type: T, listener: ListenerCallbackFnType<T>): this;
     emit(type: ListenersKeyType, args: any): boolean;
     get sipDomain(): string;
+    use(plugin: BaseNewStreamPlugin | BaseProcessStreamPlugin): void;
+    getPlugin(name: string): BaseNewStreamPlugin | BaseProcessStreamPlugin;
     begin(): this;
+    disconnect(): void;
     subscribe(type: string, listener: (c: RTCSessionExtended) => void): void;
     removeIListener(value: string): void;
     triggerListener({ listenerType, session, event }: TriggerListenerOptions): void;
@@ -707,6 +794,10 @@ declare interface OutgoingMSRPSessionEvent {
 
 declare type OutgoingMSRPSessionListener = (event: OutgoingMSRPSessionEvent) => void;
 
+declare interface PluginConfig {
+    immediate: boolean;
+}
+
 declare type readyListener = (value: boolean) => void
 
 declare interface RemoteIdentityCallType {
@@ -767,6 +858,124 @@ declare interface RTCSessionExtended extends RTCSession {
     init_icncoming(request: IncomingRequest): void
 }
 
+export declare class ScreenSharePlugin extends BaseNewStreamPlugin {
+    constructor();
+    generateStream(): Promise<MediaStream>;
+    kill(): Promise<void>;
+}
+
+declare interface ScreenShareWhiteboardOptions {
+    selectors: ScreenShareWhiteboardSelectors;
+}
+
+export declare class ScreenShareWhiteBoardPlugin extends BaseProcessStreamPlugin {
+    private static video;
+    private static wrapperEl;
+    private static screenShareKonvaDrawer;
+    private static initialStream;
+    private imageSrc;
+    private konvaDrawer;
+    mode: ConferencingModeType;
+    private screenSharePlugin;
+    private selectors;
+    constructor(screenSharePlugin: any, options?: Partial<ScreenShareWhiteboardOptions>);
+    private createVideoElement;
+    private getAspectRatioDimensions;
+    /**
+     * Starts stream processing to add mask effect for it
+     * This method is useful in cases like drawing over the screen share as we
+     * already have a screen share stream and there is no need to create another one
+     * @param {MediaStream} stream
+     * @return {MediaStream} processed stream with mask effect
+     */
+    start(stream: any): Promise<MediaStream>;
+    /**
+     * Stops stream processing
+     */
+    stop(): void;
+    setupScreenShareDrawerOptions(options: KonvaDrawerOptions): void;
+}
+
+declare interface ScreenShareWhiteboardSelectors {
+    container: string;
+    compositeCanvasContainer: string;
+    compositeCanvas: string;
+    drawerContainer: string;
+    videoElement: string;
+    videoElementContainer: string;
+    document: HTMLElement;
+}
+
+declare type startBlurListener = () => void
+
+declare type startScreenShareListener = (event: MediaStream) => void
+
+declare type stopBlurListener = () => void
+
+declare type stopScreenShareListener = () => void
+
+declare interface StreamMaskOptions {
+    effect: MaskEffectTypeConfigType;
+    base64Image?: string;
+    visualizationConfig?: VisualizationConfigType;
+}
+
+export declare class StreamMaskPlugin extends BaseProcessStreamPlugin {
+    private visualizationConfig;
+    private maskEffectType;
+    private base64ImageMask;
+    private rafId;
+    private timeoutId;
+    private segmenter;
+    private camera;
+    private canvas;
+    private ctx;
+    private visibilityState;
+    constructor(options: StreamMaskOptions, pluginConfig?: PluginConfig);
+    /**
+     * Starts stream processing to add mask effect for it
+     * @param {MediaStream} stream
+     * @param {'bokehEffect' | 'backgroundImageEffect'} effect - defines the mask effect type
+     * @param {MediaStreamConstraints} options - media stream constraints
+     * @param {object} options - (optional) additional mask effect options
+     * @return {MediaStream} processed stream with mask effect
+     */
+    start(stream: any): Promise<MediaStream>;
+    /**
+     * Listens to visibility change (like switching active tab)
+     * and switches between different kinds of requestAnimationFrame
+     */
+    private processVisibilityChange;
+    /**
+     * Adds audio tracks to MediaStream which contains only video tracks
+     * @param {MediaStream} stream - stream with only video tracks
+     * @param {MediaStreamConstraints} options - media stream constraints
+     * @return {MediaStream} combined stream with both audio and video tracks
+     */
+    private populateWithAudioTracks;
+    /**
+     * Stops stream processing
+     */
+    stop(): void;
+    setupVisualizationConfig(config: VisualizationConfigType): void;
+    /**
+     * Starts rendering process by calling itself recursively.
+     * Uses requestAnimationFrame method for recursive invoking.
+     */
+    private renderPrediction;
+    /**
+     * Creates Body Segmenter which is used for people segmentation and poses estimation
+     * @return {segmenter} segmenter instance
+     */
+    private createSegmenter;
+    /**
+     * Render function which draws masked effect to canvas.
+     */
+    private renderResult;
+    private applyBokehEffect;
+    private applyBackgroundImageEffect;
+}
+
 declare interface StreamMediaType extends HTMLAudioElement {
     className: string
     setSinkId (id: string): Promise<void>
@@ -780,6 +989,10 @@ declare interface TriggerListenerOptions {
     event?:  ListenerEventType
 }
 
+declare type UAConfigurationExtended = UAConfiguration & {
+    overrideUserAgent: (userAgent: string) => string
+}
+
 declare const UAConstructor: typeof UA;
 
 declare class UAExtended extends UAConstructor implements UAExtendedInterface {
@@ -791,15 +1004,22 @@ declare class UAExtended extends UAConstructor implements UAExtendedInterface {
         ict: {};
     };
     _janus_sessions: any[];
+    protected newStreamPlugins: Array<BaseNewStreamPlugin>;
+    protected processStreamPlugins: Array<BaseProcessStreamPlugin>;
     constructor(configuration: UAConfiguration);
     call(target: string, options?: CallOptionsExtended): RTCSession;
-    joinVideoCall(target: any, displayName: any, options: any): any;
+    joinVideoCall(target: string, displayName: string, options: VideoConferenceJoinOptions): any;
+    startScreenShare(): void;
+    changeMediaConstraints(constraints: MediaStreamConstraints): void;
+    startBlur(): void;
+    stopBlur(): void;
     _loadConfig(configuration: any): void;
     /**
      * new MSRPSession
      */
     newMSRPSession(session: MSRPSession, data: object): void;
     newJanusSession(session: any, data: any): void;
+    kill(): void;
     /**
      * MSRPSession destroyed.
      */
@@ -853,6 +1073,12 @@ declare interface UAExtendedInterface_2 extends UA {
 
 declare type updateRoomListener = (value: RoomChangeEmitType) => void
 
+declare interface VideoConferenceJoinOptions {
+    eventHandlers: Array<unknown>;
+    extraHeaders: Array<string>;
+    mediaConstraints: MediaStreamConstraints;
+}
+
 declare class VideoModule {
     private context;
     constructor(context: any);
@@ -863,10 +1089,23 @@ declare class VideoModule {
     stopAudio(): void;
     startVideo(): void;
     stopVideo(): void;
+    changeMediaConstraints(constraints: MediaStreamConstraints): void;
+    startScreenShare(): void;
+    startBlur(): void;
+    stopBlur(): void;
 }
 
 declare type VideoModuleName = typeof MODULES.VIDEO
 
+declare type VisualizationConfigType = {
+    foregroundThreshold?: number;
+    maskOpacity?: number;
+    maskBlur?: number;
+    pixelCellWidth?: number;
+    backgroundBlur?: number;
+    edgeBlur?: number;
+};
+
 declare interface WebrtcMetricsConfigType {
     refreshEvery?: number
     startAfter?: number
@@ -879,4 +1118,34 @@ declare interface WebrtcMetricsConfigType {
     ticket?: boolean
 }
 
+declare interface WhiteboardElementSelectors {
+    container: string;
+    drawerContainer: string;
+    konvaContainer: HTMLElement;
+    document: HTMLElement;
+}
+
+declare interface WhiteboardOptions {
+    mode: ConferencingModeType;
+    imageSrc?: string;
+    selectors: Partial<WhiteboardElementSelectors>;
+}
+
+export declare class WhiteBoardPlugin extends BaseNewStreamPlugin {
+    private visualizationConfig;
+    private rafId;
+    private imageSrc;
+    private konvaDrawer;
+    private selectors;
+    mode: ConferencingModeType;
+    constructor(options: WhiteboardOptions);
+    setupDrawerOptions(options: KonvaDrawerOptions): void;
+    setMode(mode: ConferencingModeType, imageSrc?: string): void;
+    setupDrawerImage(imageSrc: any): void;
+    private drawEmptyWhiteboard;
+    private drawImageWhiteboard;
+    generateStream(): Promise<void>;
+    kill(): Promise<void>;
+}
+
 export { }