@cometchat/calls-sdk-react-native 4.0.0-beta1

package/dist/models/CallAppSettings.d.ts

@@ -0,0 +1,42 @@
+import { Host, Region } from '../types/common';
+export declare class CallAppSettings {
+    private appId;
+    private region;
+    private host?;
+    constructor(builder?: CallAppSettingsBuilder);
+    setAppId(appId: string): this;
+    setRegion(region: Region): this;
+    setHost(host: Host): this;
+    getAppId(): string;
+    getRegion(): Region;
+    getHost(): Host;
+}
+export declare class CallAppSettingsBuilder {
+    appId: string;
+    region: Region;
+    host?: Host;
+    /**
+     * Method to set appId of the app.
+     * @param {string} appId appId of the app
+     * @returns
+     */
+    setAppId(appId: string): this;
+    /**
+     * Method to set region of the app.
+     * @param {Region} region region of the app.
+     * @returns {void}
+     */
+    setRegion(region: Region): this;
+    /**
+     * Method to set host/domain of the app.
+     * @param {string} host host/domain of the app.
+     * @returns {void}
+     */
+    setHost(host: Host): this;
+    /**
+     * This method will return an object of the CallsAppSettings class.
+     * @returns {CallAppSettings} Returns the CallsAppSettings instance
+     */
+    build(): CallAppSettings;
+}
+export declare function validateCallAppSettings(appSettings: CallAppSettings): Promise<true>;

package/dist/models/CallSettings.d.ts

@@ -0,0 +1,316 @@
+import { OngoingCallListener } from './Listner';
+import { CallConstants } from '../Constants';
+import { AspectRatio, Position } from '../types/common';
+export declare class CallSettings {
+    static readonly POSITION_TOP_LEFT = "top-left";
+    static readonly POSITION_TOP_RIGHT = "top-right";
+    static readonly POSITION_BOTTOM_LEFT = "bottom-left";
+    static readonly POSITION_BOTTOM_RIGHT = "bottom-right";
+    static readonly ASPECT_RATIO_DEFAULT = "default";
+    static readonly ASPECT_RATIO_CONTAIN = "contain";
+    static readonly ASPECT_RATIO_COVER = "cover";
+    static readonly POSITION: {
+        readonly TOP_LEFT: "top-left";
+        readonly TOP_RIGHT: "top-right";
+        readonly BOTTOM_LEFT: "bottom-left";
+        readonly BOTTOM_RIGHT: "bottom-right";
+    };
+    static readonly ASPECT_RATIO: {
+        readonly DEFAULT: "default";
+        readonly CONTAIN: "contain";
+        readonly COVER: "cover";
+    };
+    private defaultLayout;
+    private isAudioOnly;
+    private listener;
+    private mode;
+    private ShowEndCallButton;
+    private ShowSwitchCameraButton;
+    private ShowMuteAudioButton;
+    private ShowPauseVideoButton;
+    private ShowAudioModeButton;
+    private StartAudioMuted;
+    private StartVideoMuted;
+    private defaultAudioMode;
+    private ShowSwitchToVideoCallButton;
+    private AvatarMode;
+    private ShowRecordingButton;
+    private StartRecordingOnCallStart;
+    private MainVideoContainerSetting;
+    private EnableVideoTileClick;
+    private enableDraggableVideoTile;
+    constructor(builder: CallSettingsBuilder);
+    isAudioOnlyCall(): boolean;
+    isDefaultLayoutEnabled(): boolean;
+    getCallEventListener(): OngoingCallListener;
+    getMode(): string;
+    isEndCallButtonEnabled(): boolean;
+    isSwitchCameraButtonEnabled(): boolean;
+    isMuteAudioButtonEnabled(): boolean;
+    isPauseVideoButtonEnabled(): boolean;
+    isAudioModeButtonEnabled(): boolean;
+    getStartWithAudioMuted(): boolean;
+    getStartWithVideoMuted(): boolean;
+    getDefaultAudioMode(): string;
+    isAudioToVideoButtonEnabled(): boolean;
+    getAvatarMode(): string;
+    isRecordingButtonEnabled(): boolean;
+    shouldStartRecordingOnCallStart(): boolean;
+    getMainVideoContainerSetting(): MainVideoContainerSetting;
+    isVideoTileClickEnabled(): boolean;
+    isVideoTileDragEnabled(): boolean;
+}
+type CallModes = typeof CallConstants.CALL_MODE[keyof typeof CallConstants.CALL_MODE];
+export declare class CallSettingsBuilder {
+    /** @private */ defaultLayout: boolean;
+    /** @private */ isAudioOnly: boolean;
+    /** @private */ listener: OngoingCallListener;
+    /** @private */ mode: CallModes;
+    /** @private */ ShowEndCallButton: boolean;
+    /** @private */ ShowSwitchCameraButton: boolean;
+    /** @private */ ShowMuteAudioButton: boolean;
+    /** @private */ ShowPauseVideoButton: boolean;
+    /** @private */ ShowAudioModeButton: boolean;
+    /** @private */ StartAudioMuted: boolean;
+    /** @private */ StartVideoMuted: boolean;
+    /** @private */ defaultAudioMode: typeof CallConstants.AUDIO_MODE[keyof typeof CallConstants.AUDIO_MODE];
+    /** @private */ ShowSwitchToVideoCallButton: boolean;
+    /** @private */ AvatarMode: string;
+    /** @private */ ShowRecordingButton: boolean;
+    /** @private */ StartRecordingOnCallStart: boolean;
+    /** @private */ MainVideoContainerSetting: MainVideoContainerSetting;
+    /** @private */ EnableVideoTileClick: boolean;
+    /** @private */ enableDraggableVideoTile: boolean;
+    /**
+     *
+     * @param {boolean} defaultLayout
+     * This methods shows/hides the default button layout.
+     * If set to true the default button layout will be shown.
+     * If set to false the default button layout will be hidden.
+     * Default value is true
+     * @returns
+     */
+    enableDefaultLayout(defaultLayout: boolean): this;
+    /**
+     *
+     * @param {boolean} isAudioOnly
+     * This methods sets the type(audio/video) of the call.
+     * If set to true, the call will be strictly an audio call.
+     * If set to false, the call will be an audio-video call.
+     * Default value is false
+     * @returns
+     */
+    setIsAudioOnlyCall(isAudioOnly: boolean): this;
+    /**
+     *
+     * @param {OngoingCallListener} listener
+     * This method sets the call event listener.
+     * @returns
+     */
+    setCallEventListener(listener: OngoingCallListener): this;
+    /**
+     *
+     * @param {string} mode
+     * This method sets the mode of the call.
+     * @returns
+     */
+    setMode(mode: CallModes): this;
+    /**
+     *
+     * @param {boolean} showEndCallButton
+     * This method shows/hides the end call button.
+     * If set to true it will display the end call button.
+     * If set to false it will hide the end call button.
+     * Default value is true.
+     * @returns
+     */
+    showEndCallButton(showEndCallButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} showSwitchCameraButton
+     * This method shows/hides the switch camera button.
+     * If set to true it will display the switch camera button.
+     * If set to false it will hide the switch camera button.
+     * Note: For video call it remains hidden regardless of its value.
+     * Default value is true.
+     * @returns
+     */
+    showSwitchCameraButton(showSwitchCameraButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} showMuteAudioButton
+     * This method shows/hides the mute audio button.
+     * If set to true it will display the mute audio button.
+     * If set to false it will hide the mute audio button.
+     * Default value is true.
+     * @returns
+     */
+    showMuteAudioButton(showMuteAudioButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} showPauseVideoButton
+     * This method shows/hides the pause video button.
+     * If set to true it will display the pause video button.
+     * If set to false it will hide the pause video button.
+     * Note: For video call it remains hidden regardless of its value.
+     * Default value is true.
+     * @returns
+     */
+    showPauseVideoButton(showPauseVideoButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} showAudioModeButton
+     * This method shows/hides the audio mode button.
+     * If set to true it will display the audio mode button.
+     * If set to false it will hide the audio mode button.
+     * Default value is true.
+     * @returns
+     */
+    showAudioModeButton(showAudioModeButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} audioMuted
+     * This method allows the call to be started with audio muted.
+     * If set to true, the call will start with audio muted.
+     * Default value is false.
+     * @returns
+     */
+    startWithAudioMuted(audioMuted?: boolean): this;
+    /**
+     *
+     * @param {boolean} videoMuted
+     * This method allows the call to be started with video muted.
+     * If set to true, the call will start with video muted.
+     * Note: This method has no effect for audio calls.
+     * Default value is false.
+     * @returns
+     */
+    startWithVideoMuted(videoMuted?: boolean): this;
+    /**
+     *
+     * @param {string} audioMode
+     * This method will set the default audio mode.
+     * @returns
+     */
+    setDefaultAudioMode(audioMode: typeof CallConstants.AUDIO_MODE[keyof typeof CallConstants.AUDIO_MODE]): this;
+    /**
+     *
+     * @param {boolean} showAudioToVideoSwitchButton
+     * This method shows/hides the switch to video call button.
+     * If set to true it will display the switch to video call button.
+     * If set to false it will hide the switch to video call button.
+     * Note: For video call it remains hidden regardless of its value.
+     * Default value is true.
+     * @returns
+     */
+    showSwitchToVideoCallButton(showAudioToVideoSwitchButton?: boolean): this;
+    /**
+     *
+     * @param {string} mode
+     * This method sets the mode of avatar.
+     * The avatar mode can be circle, square or fullscreen.
+     * Default value is circle.
+     * @returns
+     */
+    setAvatarMode(mode?: 'circle' | 'square' | 'fullscreen'): this;
+    /**
+     *
+     * @param {boolean} showRecordingButton
+     * This method shows/hides the recording button.
+     * If set to true it will display the recording button.
+     * If set to false it will hide the recording button.
+     * Default value is false.
+     * @returns
+     */
+    showRecordingButton(showRecordingButton?: boolean): this;
+    /**
+     *
+     * @param {boolean} startRecordingOnCallStart
+     * This method starts the recording as soon as the call start.
+     * If set to true it will start the recording as soon as the call start.
+     * Default value is false.
+     * @returns
+     */
+    startRecordingOnCallStart(startRecordingOnCallStart?: boolean): this;
+    /**
+     *
+     * @param {MainVideoContainerSetting} mainVideoContainerSetting
+     * This method can be used to customize the main video container.
+     * @returns
+     */
+    setMainVideoContainerSetting(mainVideoContainerSetting: MainVideoContainerSetting): this;
+    /**
+     *
+     * @param {boolean} enableVideoTileClick
+     * This method can be used to enable/disable video tile click functionality in Spotlight mode.
+     * By default the video tile is clickable.
+     * @returns
+     */
+    enableVideoTileClick(enableVideoTileClick?: boolean): this;
+    /**
+     *
+     * @param {boolean} enableVideoTileDrag
+     * This method can be used to enable/disable video tile drag functionality in Spotlight mode.
+     * By default the video tile is draggable.
+     * @returns
+     */
+    enableVideoTileDrag(enableVideoTileDrag?: boolean): this;
+    /**
+     * This method will return an object of the CallSettings class.
+     * @returns {CallSettings}
+     */
+    build(): CallSettings;
+}
+export declare class MainVideoContainerSetting {
+    private videoFit;
+    private zoomButton;
+    private fullScreenButton;
+    private userListButton;
+    private nameLabel;
+    /**
+     *
+     * @param {string} mainVideoAspectRatio
+     * This method is used to set the aspect ratio of main video.
+     * The default value is `contain`.
+     * @returns
+     */
+    setMainVideoAspectRatio(mainVideoAspectRatio?: AspectRatio): void;
+    /**
+     *
+     * @param {Position} position
+     * @param {boolean} visibility
+     * This method is used to set the position & visibility parameter of the full screen button.
+     * By default the full screen button is visible in the `bottom-right` position.
+     * @returns
+     */
+    setFullScreenButtonParams(position?: Position, visibility?: boolean): void;
+    /**
+     *
+     * @param {Position} position
+     * @param {boolean} visibility
+     * @param {string} backgroundColor
+     * This method is used to set the position, visibility & background color of the name label.
+     * By default the name label is visible in the `bottom-left` position with a background-color `#333333`
+     * @returns
+     */
+    setNameLabelParams(position?: Position, visibility?: boolean, backgroundColor?: string): void;
+    /**
+     *
+     * @param {Position} position
+     * @param {boolean} visibility
+     * This method is used to set the position & visibility parameter of the zoom button.
+     * By default the zoom button is visible in the `bottom-right` position.
+     * @returns
+     */
+    setZoomButtonParams(position?: Position, visibility?: boolean): void;
+    /**
+     *
+     * @param {Position} position
+     * @param {boolean} visibility
+     * This method is used to set the position & visibility parameter of the user list button.
+     * By default the user list button is visible in the `bottom-right` position.
+     * @returns
+     */
+    setUserListButtonParams(position?: Position, visibility?: boolean): void;
+}
+export {};

package/dist/models/CometChatCalls.d.ts

@@ -0,0 +1,89 @@
+import { ListenerHandlers } from './ListnerHandler';
+import { AudioMode } from '../types/common';
+import { CallAppSettings, CallAppSettingsBuilder } from './CallAppSettings';
+import { CallSettings, CallSettingsBuilder } from './CallSettings';
+import { CometChatCallsComponentCore as CometChatCallsComponent } from './CometChatCallsComponentCore';
+import { CometChatPresenterComponent } from './CometChatPresenterComponent';
+import { OngoingCallListener } from './Listner';
+import { PresenterSettings, PresenterSettingsBuilder } from './PresenterSettings';
+export declare class CometChatCalls {
+    private static appSettings;
+    static CALL_MODE: {
+        readonly DEFAULT: "DEFAULT";
+        readonly SPOTLIGHT: "SPOTLIGHT";
+    };
+    static AUDIO_MODE: {
+        readonly SPEAKER: "SPEAKER";
+        readonly EARPIECE: "EARPIECE";
+        readonly BLUETOOTH: "BLUETOOTH";
+        readonly HEADPHONES: "HEADPHONES";
+    };
+    static addCallEventListener: typeof ListenerHandlers.addCallEventListener;
+    static removeCallEventListener: typeof ListenerHandlers.removeCallEventListener;
+    static OngoingCallListener: typeof OngoingCallListener;
+    static CallSettingsBuilder: typeof CallSettingsBuilder;
+    static CallSettings: typeof CallSettings;
+    static PresenterSettingsBuilder: typeof PresenterSettingsBuilder;
+    static PresenterSettings: typeof PresenterSettings;
+    static CallAppSettingsBuilder: typeof CallAppSettingsBuilder;
+    static CallAppSettings: typeof CallAppSettings;
+    static Component: typeof CometChatCallsComponent;
+    static PresenterComponent: typeof CometChatPresenterComponent;
+    static generateToken(sessionID: string, authToken: string): Promise<{
+        token: string;
+    }>;
+    static init(appSettings: CallAppSettings): Promise<void>;
+    /**
+     * Method end on-going call.
+     * @returns {void}
+     */
+    static endCall(): void;
+    /**
+     * Method to mute/unmute audio stream.
+     * @param {boolean} muteAudio
+     * @returns {void}
+     */
+    static muteAudio(muteAudio: boolean): void;
+    /**
+     * Method to pause/unpause video stream.
+     * @param {boolean} pauseVideo
+     * @returns {void}
+     */
+    static pauseVideo(pauseVideo: boolean): void;
+    /**
+     * Method to resume video stream.
+     * @returns {void}
+     */
+    static resumeVideo(): void;
+    /**
+     * Method to set audio mode.
+     * @param {string} mode
+     * @returns {void}
+     */
+    static setAudioMode(mode: string): void;
+    /**
+     * Method to switch camera.
+     * @returns {void}
+     */
+    static switchCamera(): void;
+    /**
+     * Method to get all the available audio output devices.
+     * @returns {Promise<AudioMode[]>}
+     */
+    static getAudioOutputModes(): Promise<AudioMode[]>;
+    /**
+     * Method to switch from audio call to video call.
+     * @returns {void}
+     */
+    static switchToVideoCall(): void;
+    /**
+     * Method to Start Call Recording.
+     * @returns {void}
+     */
+    static startRecording(): void;
+    /**
+     * Method to Stop Call Recording.
+     * @returns {void}
+     */
+    static stopRecording(): void;
+}

package/dist/models/CometChatCallsComponent.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { CallSettings } from './CallSettings';
+type MyState = {
+    errored: boolean;
+};
+export declare class CometChatCallsComponent extends React.Component<{
+    callSettings: CallSettings;
+    callToken: string;
+}, MyState> {
+    constructor(props: any);
+    render(): JSX.Element;
+}
+export {};

package/dist/models/CometChatCallsComponentCore.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { CallSettings } from './CallSettings';
+import { PresenterSettings } from './PresenterSettings';
+type MyState = {
+    shouldLoad: boolean;
+    errored: boolean;
+};
+export declare class CometChatCallsComponentCore extends React.Component<{
+    callSettings: CallSettings | PresenterSettings;
+    callToken: string;
+    presenterMode?: boolean;
+}, MyState> {
+    static ref: any;
+    callsettings: CallSettings | PresenterSettings;
+    constructor(props: any);
+    render(): JSX.Element;
+}
+export {};

package/dist/models/CometChatCallsException.d.ts

@@ -0,0 +1,7 @@
+import { ErrorModel } from "./ErrorModel";
+export declare class CometChatCallsException {
+    code: ErrorModel["code"];
+    message?: ErrorModel["message"];
+    details?: ErrorModel["details"];
+    constructor(errorModel: ErrorModel);
+}

package/dist/models/CometChatPresenterComponent.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { PresenterSettings } from './PresenterSettings';
+type MyState = {
+    errored: boolean;
+};
+export declare class CometChatPresenterComponent extends React.Component<{
+    presenterSettings: PresenterSettings;
+    callToken: string;
+}, MyState> {
+    constructor(props: any);
+    render(): JSX.Element;
+}
+export {};

package/dist/models/ErrorModel.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ *
+ * @export
+ * @interface ErrorModel
+ */
+export interface ErrorModel {
+    code: string | number;
+    message?: string;
+    details?: string;
+}

package/dist/models/Listner.d.ts

@@ -0,0 +1,64 @@
+import { ICallEventsData } from '../types/callEvents';
+import { CometChatCallsException } from './CometChatCallsException';
+interface IOngoingCallListener {
+    onUserJoined: (user: Partial<ICallEventsData['onUserJoined']>) => void;
+    onUserLeft: (user: Partial<ICallEventsData['onUserLeft']>) => void;
+    onUserListUpdated: (userList: Partial<ICallEventsData['onUserListUpdated']>) => void;
+    onMediaDeviceListUpdated: (devices: Partial<ICallEventsData['onMediaDeviceListUpdated']>) => void;
+    onRecordingStarted: (data: Partial<ICallEventsData['onRecordingStarted']>) => void;
+    onRecordingStopped: (data: Partial<ICallEventsData['onRecordingStopped']>) => void;
+    onUserMuted: (test: Partial<ICallEventsData["onUserMuted"]>) => void;
+    onCallSwitchedToVideo: (data: Partial<ICallEventsData['onCallSwitchedToVideo']>) => void;
+    onCallEnded: () => void;
+    onCallEndButtonPressed: () => void;
+    onAudioModesUpdated: (any: any) => void;
+    onError: (error: CometChatCallsException) => void;
+}
+export declare class OngoingCallListener {
+    /**
+     * This event is triggered when a user joins the call.
+     */
+    onUserJoined?: IOngoingCallListener["onUserJoined"];
+    /**
+     * This event is triggered when a user leaves the call.
+     */
+    onUserLeft?: IOngoingCallListener["onUserLeft"];
+    /**
+     * This event is triggered when the participant list of the call changes.
+     */
+    onUserListUpdated?: IOngoingCallListener["onUserListUpdated"];
+    /**
+     * This event is triggered when an audio mode is updated.
+     */
+    onAudioModesUpdated?: IOngoingCallListener["onAudioModesUpdated"];
+    /**
+     * This event is triggered when the call is ended.
+     */
+    onCallEnded?: IOngoingCallListener["onCallEnded"];
+    /**
+     * This event is triggered when end call button is pressed.
+     */
+    onCallEndButtonPressed?: IOngoingCallListener["onCallEndButtonPressed"];
+    /**
+     * This event is triggered when an error occurs.
+     */
+    onError?: IOngoingCallListener["onError"];
+    /**
+     * This event is triggered when someone starts recording the call.
+     */
+    onRecordingStarted?: IOngoingCallListener["onRecordingStarted"];
+    /**
+     * This event is triggered when someone stops recording the call.
+     */
+    onRecordingStopped?: IOngoingCallListener["onRecordingStopped"];
+    /**
+     * This event is triggered when a user is muted.
+     */
+    onUserMuted?: IOngoingCallListener["onUserMuted"];
+    /**
+     * This event is triggered when an audio call is switched to a video call.
+     */
+    onCallSwitchedToVideo?: IOngoingCallListener["onCallSwitchedToVideo"];
+    constructor(eventObj: Partial<IOngoingCallListener>);
+}
+export {};

package/dist/models/ListnerHandler.d.ts

@@ -0,0 +1,10 @@
+import { OngoingCallListener } from './Listner';
+interface IMultiOngoingCallListener extends OngoingCallListener {
+    _name: string;
+}
+export declare class ListenerHandlers {
+    static callHandlers?: IMultiOngoingCallListener[];
+    static addCallEventListener(name: string, callListener: OngoingCallListener): void;
+    static removeCallEventListener(handler: string): void;
+}
+export {};

package/dist/models/MessageComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare class MessageComponent extends React.Component<{
+    message: string;
+}> {
+    constructor(props: any);
+    render(): JSX.Element;
+}