@flashphoner/websdk 2.0.202 → 2.0.207

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@flashphoner/websdk",
-  "version": "2.0.202",
+  "version": "2.0.207",
   "description": "Official Flashphoner WebCallServer WebSDK package",
   "main": "./src/flashphoner-core.js",
+  "types": "./src/flashphoner-core.d.ts",
   "dependencies": {
     "adapterjs": "0.15.5",
     "es6-promise": "4.0.5",

package/src/constants.d.ts

@@ -0,0 +1 @@
+export default constants as any;

package/src/flashphoner-core.d.ts

@@ -0,0 +1,192 @@
+export declare class Call {
+    call: () => void;
+    answer: (answerOptions: {
+        localVideoDisplay: HTMLElement;
+        remoteVideoDisplay: HTMLElement;
+        receiveAudio?: boolean | undefined;
+        receiveVideo?: boolean | undefined;
+        constraints?: string | undefined;
+        stripCodecs?: Array<string> | undefined;
+        sipSDP?: Array<string> | undefined;
+        sipHeaders?: Array<string> | undefined;
+    }) => void;
+    hangup: () => void;
+    id: () => string;
+    getInfo: () => string;
+    getErrorInfo: () => string;
+    status: () => string;
+    getStats: (callbackFn: any, nativeStats: boolean) => any;
+    setAudioOutputId: (id: string) => any;
+    setVolume: (volume: number) => void;
+    getVolume: () => number;
+    muteAudio: () => void;
+    unmuteAudio: () => void;
+    isVideoMuted: () => boolean;
+    caller: () => string;
+    callee: () => string;
+    visibleName: () => string;
+    hold: () => void;
+    holdForTransfer: () => void;
+    unhold: () => void;
+    sendDTMF: (number: number, type?: string | undefined) => void;
+    transfer: (target: any) => void;
+    on: (event: string, callback: any) => Call;
+    switchCam: (deviceId: any) => any;
+    switchMic: (deviceId: any) => any;
+    switchToScreen: (source: string, woExtension: boolean) => any;
+    switchToCam: () => void;
+}
+
+export declare class Stream {
+    play: () => void;
+    publish: () => void;
+    stop: () => void;
+    id: () => string;
+    status: () => string;
+    name: () => string;
+    published: () => boolean;
+    getRecordInfo: () => string;
+    getInfo: () => string;
+    getErrorInfo: () => string;
+    videoResolution: () => any;
+    setAudioOutputId: (id: string) => any;
+    setVolume: (volume: number) => void;
+    unmuteRemoteAudio: () => void;
+    muteRemoteAudio: () => void;
+    isRemoteAudioMuted: () => boolean;
+    setMicrophoneGain: (volume: number) => void;
+    getVolume: () => number;
+    muteAudio: () => void;
+    unmuteAudio: () => void;
+    isAudioMuted: () => boolean;
+    muteVideo: () => void;
+    unmuteVideo: () => void;
+    isVideoMuted: () => boolean;
+    getStats: (callbackFn: any, nativeStats: boolean) => any;
+    snapshot: () => void;
+    getAudioState: () => any;
+    getVideoState: () => any;
+    getNetworkBandwidth: () => number;
+    getRemoteBitrate: () => number;
+    fullScreen: () => void;
+    on: (event: string, callback: any) => Stream;
+    available: () => any;
+    switchCam: (deviceId: any) => any;
+    switchMic: (deviceId: any) => any;
+    switchToScreen: (source: string, woExtension: boolean) => any;
+    switchToCam: () => void;
+    sendData: (payload: any) => void;
+}
+
+export declare class Session {
+    id: () => string;
+    status: () => string;
+    getServerUrl: () => string;
+    createStream: (options: {
+        name: string;
+        constraints?: any | undefined;
+        mediaProvider: string;
+        receiveAudio?: boolean | undefined;
+        receiveVideo?: boolean | undefined;
+        cacheLocalResources?: boolean | undefined;
+        playWidth?: number | undefined;
+        playHeight?: number | undefined;
+
+    }) => Stream;
+    createCall: (options: {
+        callee: string;
+        visibleName?: string | undefined;
+        constraints: any;
+        mediaProvider: string;
+        receiveAudio?: boolean | undefined;
+        receiveVideo?: boolean | undefined;
+        cacheLocalResources?: boolean | undefined;
+        localVideoDisplay: HTMLElement;
+        remoteVideoDisplay: HTMLElement;
+        custom?: any | undefined;
+        stripCodecs?: Array<string> | undefined;
+        sipSDP?: Array<string> | undefined;
+        sipHeaders?: Array<string> | undefined;
+        videoContentHint?: string | undefined;
+    }) => Call;
+    getStream: (streamId: string) => any;
+    getStreams: () => any[];
+    sendData: (data: any) => any;
+    disconnect: () => void;
+    submitBugReport: (reportObject: any) => void;
+    startDebug: () => void;
+    stopDebug: () => void;
+    on: (event: string, callback: any) => Session;
+}
+
+export namespace Browser {
+    export function isIE(): boolean;
+    export function isFirefox(): boolean;
+    export function isChrome(): boolean;
+    export function isEdge(): boolean;
+    export function isOpera(): boolean;
+    export function isiOS(): boolean;
+    export function isSafari(): boolean;
+    export function isAndroid(): boolean;
+    export function isSafariWebRTC(): boolean;
+    export function isSamsungBrowser(): boolean;
+    export function isAndroidFirefox(): boolean;
+}
+
+export function init(options: {
+    mediaProvidersReadyCallback?: Function | undefined;
+    flashMediaProviderSwfLocation?: string | undefined;
+    preferredMediaProvider?: string | undefined;
+    preferredMediaProviders?: any[] | undefined;
+    receiverLocation?: string | undefined;
+    decoderLocation?: string | undefined;
+    screenSharingExtensionId?: string | undefined;
+    constraints?: any | undefined;
+    logger?: any | undefined;
+}): void;
+export function isUsingTemasys(): boolean;
+export function getMediaProviders(): any[];
+export function getMediaDevices(
+    mediaProvider: string | undefined,
+    labels: boolean | undefined,
+    kind: any,
+    deviceConstraints: any | undefined): any;
+export function getMediaAccess(
+    constraints: {
+        audio: {
+            deviceId?: string | undefined;
+        };
+        video: {
+            deviceId?: string | undefined;
+            width: number;
+            height: number;
+            frameRate: number;
+            type: string;
+            mediaSource: string;
+        };
+    }, display: HTMLElement, mediaProvider: string, disableConstraintsNormalization: boolean): any;
+export function releaseLocalMedia(display: HTMLElement, mediaProvider?: string | undefined): boolean;
+export function getSessions(): any[];
+export function getSession(id: string): any;
+export function createSession(options: {
+    urlServer: string;
+    authToken?: string;
+    keepAlive?: boolean | undefined;
+    lbUrl?: string | undefined;
+    flashProto?: string | undefined;
+    flashPort?: any | undefined;
+    appKey?: string | undefined;
+    custom?: any | undefined;
+    sipOptions?: any | undefined;
+    mediaOptions?: any | undefined;
+    timeout?: any | undefined;
+}): Session;
+export function playFirstSound (noise?: boolean): any;
+export function playFirstVideo (display: any, isLocal: boolean, src: any): any;
+export function getLogger(): any;
+import { constants } from "@flashphoner/websdk/src/constants";
+export declare const firefoxScreenSharingExtensionInstalled: boolean;
+export { constants };
+
+
+

package/src/flashphoner-core.js

@@ -534,7 +534,7 @@ var createSession = function (options) {
                 mediaProviders: Object.keys(MediaProvider),
                 keepAlive: keepAlive,
                 authToken:authToken,
-                clientVersion: "2.0.202",
+                clientVersion: "2.0.207",
                 clientOSVersion: window.navigator.appVersion,
                 clientBrowserVersion: window.navigator.userAgent,
                 msePacketizationVersion: 2,
@@ -719,7 +719,7 @@ var createSession = function (options) {
      * @param {HTMLElement} options.localVideoDisplay Div element local video should be displayed in
      * @param {HTMLElement} options.remoteVideoDisplay Div element remote video should be displayed in
      * @param {Object=} options.custom User provided custom object that will be available in REST App code
-     * @param {Array<string>=} options.stripCodecs Array of codecs which should be stripped from SDP (WebRTC)
+     * @param {string=} options.stripCodecs Comma separated strings of codecs which should be stripped from WebRTC SDP (ex. "SILK,G722")
      * @param {Array<string>=} options.sipSDP Array of custom SDP params (ex. bandwidth (b=))
      * @param {Array<string>=} options.sipHeaders Array of custom SIP headers
      * @param {string=} options.videoContentHint Video content hint for browser ('detail' by default to maintain resolution), {@link Flashphoner.constants.CONTENT_HINT_TYPE}
@@ -959,7 +959,7 @@ var createSession = function (options) {
          * @param {Boolean=} answerOptions.receiveAudio Receive audio
          * @param {Boolean=} answerOptions.receiveVideo Receive video
          * @param {String=} answerOptions.constraints Answer call with constraints
-         * @param {Array<string>=} answerOptions.stripCodecs Array of codecs which should be stripped from SDP (WebRTC)
+         * @param {String=} answerOptions.stripCodecs Comma separated string of codecs which should be stripped from WebRTC SDP (ex. "SILK,G722")
          * @param {Array<string>=} answerOptions.sipSDP Array of custom SDP params (ex. bandwidth (b=))
          * @param {Array<string>=} answerOptions.sipHeaders Array of custom SIP headers
          * @param {sdpHook} sdpHook The callback that handles sdp from the server
@@ -1472,7 +1472,7 @@ var createSession = function (options) {
      * @param {HTMLElement} options.display Div element stream should be displayed in
      * @param {Object=} options.custom User provided custom object that will be available in REST App code
      * @param {Integer} [options.flashBufferTime=0] Specifies how long to buffer messages before starting to display the stream (Flash-only)
-     * @param {Array<string>=} options.stripCodecs Array of codecs which should be stripped from SDP (WebRTC)
+     * @param {String=} options.stripCodecs Comma separated string of codecs which should be stripped from WebRTC SDP (ex. "H264,PCMA,PCMU,G722")
      * @param {string=} options.rtmpUrl Rtmp url stream should be forwarded to
      * @param {Object=} options.mediaConnectionConstraints Stream specific constraints for underlying RTCPeerConnection
      * @param {Boolean=} options.flashShowFullScreenButton Show full screen button in flash

package/src/room-module.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Room api based on core api
+ *
+ * @namespace roomApi
+ */
+/**
+ * Initialize connection
+ *
+ * @param {Object} options session options
+ * @param {String} options.urlServer Server address in form of [ws,wss]://host.domain:port
+ * @param {String} options.username Username to login with
+ * @returns {roomApi.Session}
+ * @memberof roomApi
+ * @method connect
+ */
+declare function appSession(options: {
+    urlServer: string;
+    username: string;
+}): any;
+export namespace events {
+    const STATE: string;
+    const JOINED: string;
+    const LEFT: string;
+    const PUBLISHED: string;
+    const MESSAGE: string;
+    const FAILED: string;
+}
+import Flashphoner = require("@flashphoner/websdk/src/flashphoner-core");
+export { appSession as connect, Flashphoner as sdk };

package/src/webrtc-media-provider.js

@@ -417,14 +417,14 @@ var createConnection = function (options) {
                                 if (!report.isRemote) {
                                     if (report.type == 'outbound-rtp') {
                                         fillStatObject(result.outboundStream, report);
-                                        if (report.mediaType == 'video') {
+                                        if (report.mediaType == 'video' && localVideo != undefined && localVideo != null) {
                                             var vSettings = localVideo.srcObject.getVideoTracks()[0].getSettings();
                                             result.outboundStream[report.mediaType].height = vSettings.height;
                                             result.outboundStream[report.mediaType].width = vSettings.width;
                                         }
                                     } else if (report.type == 'inbound-rtp') {
                                         fillStatObject(result.inboundStream, report);
-                                        if (report.mediaType == 'video' && remoteVideo != undefined) {
+                                        if (report.mediaType == 'video' && remoteVideo != undefined && remoteVideo != null) {
                                             result.inboundStream[report.mediaType].height = remoteVideo.videoHeight;
                                             result.inboundStream[report.mediaType].width = remoteVideo.videoWidth;
                                         }