index.d.ts

declare module "react-native-callkeep" {
  export type NativeEvents = {
    didReceiveStartCallAction: "RNCallKeepDidReceiveStartCallAction";
    answerCall: "RNCallKeepPerformAnswerCallAction";
    endCall: "RNCallKeepPerformEndCallAction";
    didActivateAudioSession: "RNCallKeepDidActivateAudioSession";
    didDeactivateAudioSession: "RNCallKeepDidDeactivateAudioSession";
    didDisplayIncomingCall: "RNCallKeepDidDisplayIncomingCall";
    didPerformSetMutedCallAction: "RNCallKeepDidPerformSetMutedCallAction";
    didToggleHoldCallAction: "RNCallKeepDidToggleHoldAction";
    didChangeAudioRoute: "RNCallKeepDidChangeAudioRoute";
    didPerformDTMFAction: "RNCallKeepDidPerformDTMFAction";
    showIncomingCallUi: "RNCallKeepShowIncomingCallUi";
    silenceIncomingCall: "RNCallKeepOnSilenceIncomingCall";
    createIncomingConnectionFailed: "RNCallKeepOnIncomingConnectionFailed";
    checkReachability: "RNCallKeepCheckReachability";
    didResetProvider: "RNCallKeepProviderReset";
    didLoadWithEvents: "RNCallKeepDidLoadWithEvents";
    onHasActiveCall: "onHasActiveCall";
  };

  export type InitialEvents = Array<
    {
      [Event in Events]: {
        name: NativeEvents[Event];
        data: EventsPayload[Event];
      };
    }[Events]
  >;

  export type Events = keyof NativeEvents;
  export type EventsPayload = {
    didReceiveStartCallAction: {
      handle: string;
      callUUID?: string;
      name?: string;
    };
    answerCall: { callUUID: string };
    endCall: { callUUID: string };
    didActivateAudioSession: undefined;
    didDeactivateAudioSession: undefined;
    didDisplayIncomingCall: {
      error?: string;
      errorCode?:
        | "Unentitled"
        | "CallUUIDAlreadyExists"
        | "FilteredByDoNotDisturb"
        | "FilteredByBlockList"
        | "Unknown";
      callUUID: string;
      handle: string;
      localizedCallerName: string;
      hasVideo: "1" | "0";
      fromPushKit: "1" | "0";
      payload: object;
    };
    didPerformSetMutedCallAction: { muted: boolean; callUUID: string };
    didToggleHoldCallAction: { hold: boolean; callUUID: string };
    didChangeAudioRoute: {
      output: string;
      reason?: number;
      handle?: string;
      callUUID?: string;
    };
    didPerformDTMFAction: { digits: string; callUUID: string };
    showIncomingCallUi: { handle: string; callUUID: string; name: string };
    silenceIncomingCall: { handle: string; callUUID: string; name: string };
    createIncomingConnectionFailed: {
      handle: string;
      callUUID: string;
      name: string;
    };
    checkReachability: undefined;
    didResetProvider: undefined;
    didLoadWithEvents: InitialEvents;
    onHasActiveCall: undefined;
  };

  type HandleType = "generic" | "number" | "email";

  export type AudioRoute = {
    name: string;
    type: string;
    selected?: boolean;
  };

  export enum AudioSessionCategoryOption {
    mixWithOthers = 0x1,
    duckOthers = 0x2,
    interruptSpokenAudioAndMixWithOthers = 0x11,
    allowBluetooth = 0x4,
    allowBluetoothA2DP = 0x20,
    allowAirPlay = 0x40,
    defaultToSpeaker = 0x8,
    overrideMutedMicrophoneInterruption = 0x80,
  }

  export enum AudioSessionMode {
    default = "AVAudioSessionModeDefault",
    gameChat = "AVAudioSessionModeGameChat",
    measurement = "AVAudioSessionModeMeasurement",
    moviePlayback = "AVAudioSessionModeMoviePlayback",
    spokenAudio = "AVAudioSessionModeSpokenAudio",
    videoChat = "AVAudioSessionModeVideoChat",
    videoRecording = "AVAudioSessionModeVideoRecording",
    voiceChat = "AVAudioSessionModeVoiceChat",
    voicePrompt = "AVAudioSessionModeVoicePrompt",
  }

  interface IOptions {
    ios: {
      appName: string;
      imageName?: string;
      supportsVideo?: boolean;
      maximumCallGroups?: string;
      maximumCallsPerCallGroup?: string;
      ringtoneSound?: string;
      includesCallsInRecents?: boolean;
      audioSession?: {
        categoryOptions?: AudioSessionCategoryOption | number;
        mode?: AudioSessionMode | string;
      };
    };
    android: {
      alertTitle: string;
      alertDescription: string;
      cancelButton: string;
      okButton: string;
      imageName?: string;
      additionalPermissions: string[];
      selfManaged?: boolean;
      foregroundService?: {
        channelId: string;
        channelName: string;
        notificationTitle: string;
        notificationIcon?: string;
      };
    };
  }

  export const CONSTANTS: {
    END_CALL_REASONS: {
      FAILED: 1;
      REMOTE_ENDED: 2;
      UNANSWERED: 3;
      ANSWERED_ELSEWHERE: 4;
      DECLINED_ELSEWHERE: 5 | 2;
      MISSED: 2 | 6;
    };
  };

  export class EventListener {
    remove(): void;
  }

  export default class RNCallKeep {
    static getInitialEvents(): Promise<InitialEvents>;

    static clearInitialEvents(): void;

    static addEventListener<Event extends Events>(
      type: Event,
      handler: (args: EventsPayload[Event]) => void
    ): EventListener;

    static removeEventListener(type: Events): void;

    static setup(options: IOptions): Promise<boolean>;

    static hasDefaultPhoneAccount(): boolean;

    static answerIncomingCall(uuid: string): void;

    static registerPhoneAccount(options: IOptions): void;

    static registerAndroidEvents(): void;

    static unregisterAndroidEvents(): void;

    static displayIncomingCall(
      uuid: string,
      handle: string,
      localizedCallerName?: string,
      handleType?: HandleType,
      hasVideo?: boolean,
      options?: object
    ): void;

    static startCall(
      uuid: string,
      handle: string,
      contactIdentifier?: string,
      handleType?: HandleType,
      hasVideo?: boolean
    ): void;

    static updateDisplay(
      uuid: string,
      displayName: string,
      handle: string,
      options?: object
    ): void;

    static checkPhoneAccountEnabled(): Promise<boolean>;

    static isConnectionServiceAvailable(): Promise<boolean>;

    /**
     * @description reportConnectedOutgoingCallWithUUID method is available only on iOS.
     */
    static reportConnectedOutgoingCallWithUUID(uuid: string): void;

    /**
     * @description reportConnectedOutgoingCallWithUUID method is available only on iOS.
     */
    static reportConnectingOutgoingCallWithUUID(uuid: string): void;

    static reportEndCallWithUUID(uuid: string, reason: number): void;

    static rejectCall(uuid: string): void;

    static endCall(uuid: string): void;

    static endAllCalls(): void;

    static setReachable(): void;

    static setSettings(settings: IOptions): void;

    /**
     * @description isCallActive method is available only on iOS.
     */
    static isCallActive(uuid: string): Promise<boolean>;

    static getCalls(): Promise<
      | {
          callUUID: string;
          hasConnected: boolean;
          hasEnded: boolean;
          onHold: boolean;
          outgoing: boolean;
        }[]
      | void
    >;

    static getAudioRoutes(): Promise<AudioRoute[]>;

    static setAudioRoute: (
      uuid: string,
      inputName: AudioRoute["type"]
    ) => Promise<void>;

    /**
     * @description supportConnectionService method is available only on Android.
     */
    static supportConnectionService(): boolean;

    /**
     * @description hasPhoneAccount method is available only on Android.
     */
    static hasPhoneAccount(): Promise<boolean>;

    static hasOutgoingCall(): Promise<boolean>;

    /**
     * @description setMutedCall method is available only on iOS.
     */
    static setMutedCall(uuid: string, muted: boolean): void;

    /**
     * @description toggleAudioRouteSpeaker method is available only on Android.
     * @param uuid
     * @param routeSpeaker
     */
    static toggleAudioRouteSpeaker(uuid: string, routeSpeaker: boolean): void;

    static setOnHold(uuid: string, held: boolean): void;

    static setConnectionState(uuid: string, state: number): void;

    /**
     * @descriptions sendDTMF is used to send DTMF tones to the PBX.
     */
    static sendDTMF(uuid: string, key: string): void;

    static checkIfBusy(): Promise<boolean>;

    static checkSpeaker(): Promise<boolean>;

    /**
     * @description setAvailable method is available only on Android.
     */
    static setAvailable(active: boolean): void;

    static setForegroundServiceSettings(
      settings: NonNullable<IOptions["android"]["foregroundService"]>
    ): void;

    static canMakeMultipleCalls(allow: boolean): void;

    static setCurrentCallActive(callUUID: string): void;

    static backToForeground(): void;

    /**
     * @descriptions Android Only, Check if there is active native call
     */
    static checkIsInManagedCall(): Promise<boolean>;
  }
}