@stream-io/react-native-callingx 0.1.0-beta.0

package/android/src/main/java/io/getstream/rn/callingx/repo/TelecomCallRepository.kt

@@ -0,0 +1,438 @@
+package io.getstream.rn.callingx.repo
+
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.telecom.CallAttributesCompat
+import androidx.core.telecom.CallControlResult
+import androidx.core.telecom.CallControlScope
+import androidx.core.telecom.CallsManager
+import io.getstream.rn.callingx.debugLog
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.model.CallAction
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.scan
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * The central repository that keeps track of the current call and allows to register new calls.
+ *
+ * This class contains the main logic to integrate with Telecom SDK.
+ *
+ * @see registerCall
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+class TelecomCallRepository(context: Context) : CallRepository(context) {
+
+    companion object {
+        private const val TAG = "[Callingx] TelecomCallRepository"
+    }
+
+    private var observeCallStateJob: Job? = null
+
+    private val callsManager: CallsManager
+    private var isSelfAnswered = false
+    private var isSelfDisconnected = false
+
+    init {
+        val capabilities =
+                CallsManager.CAPABILITY_SUPPORTS_CALL_STREAMING or
+                        CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING
+        callsManager =
+                CallsManager(context.applicationContext).apply {
+                    registerAppWithTelecom(capabilities)
+                }
+        debugLog(TAG, "[repository] init: CallsManager created and registered")
+    }
+
+    override fun getTag(): String = TAG
+
+    override fun setListener(listener: Listener?) {
+        this._listener = listener
+
+        observeCallStateJob?.cancel()
+        observeCallStateJob = observeCallState()
+    }
+
+    override fun release() {
+        val currentCall = currentCall.value
+        if (currentCall is Call.Registered) {
+            currentCall.processAction(CallAction.Disconnect(DisconnectCause(DisconnectCause.LOCAL)))
+        }
+        _currentCall.value = Call.None
+
+        observeCallStateJob?.cancel()
+        observeCallStateJob = null
+        _listener = null
+
+        scope.cancel()
+    }
+
+    /**
+     * Register a new call with the provided attributes. Use the [currentCall] StateFlow to receive
+     * status updates and process call related actions.
+     */
+    override suspend fun registerCall(
+            callId: String,
+            displayName: String,
+            address: Uri,
+            isIncoming: Boolean,
+            isVideo: Boolean,
+            displayOptions: Bundle?,
+    ) {
+        debugLog(
+                TAG,
+                "[repository] registerCall: Starting registration - Name: $displayName, Address: $address, Incoming: $isIncoming"
+        )
+
+        registrationMutex.withLock {
+            // For simplicity we don't support multiple calls
+            if (_currentCall.value is Call.Registered) {
+                Log.w(
+                        TAG,
+                        "[repository] registerCall: Call already registered, ignoring new call request"
+                )
+                return@withLock
+            }
+            debugLog(
+                    TAG,
+                    "[repository] registerCall: No existing call found, proceeding with registration"
+            )
+
+            val attributes = createCallAttributes(displayName, address, isIncoming, isVideo)
+            val actionSource = Channel<CallAction>()
+
+            // Register the call and handle actions in the scope
+            try {
+                callsManager.addCall(
+                        attributes,
+                        onIsCallAnswered, // Watch needs to know if it can answer the call
+                        onIsCallDisconnected,
+                        onIsCallActive,
+                        onIsCallInactive
+                ) {
+                    debugLog(
+                            TAG,
+                            "[repository] registerCall: Inside call scope, setting up call handlers"
+                    )
+
+                    // Consume the actions to interact with the call inside the scope
+                    launch { processCallActions(actionSource.consumeAsFlow()) }
+
+                    // Update the state to registered with default values while waiting for Telecom
+                    // updates
+                    debugLog(
+                            TAG,
+                            "[repository] registerCall: Creating Registered call state with ID: $callId"
+                    )
+                    _currentCall.value =
+                            Call.Registered(
+                                    id = callId,
+                                    isActive = false, // can we just register the call as active?
+                                    isOnHold = false,
+                                    callAttributes = attributes,
+                                    displayOptions = displayOptions,
+                                    isMuted = false,
+                                    errorCode = null,
+                                    currentCallEndpoint = null,
+                                    availableCallEndpoints = emptyList(),
+                                    actionSource = actionSource,
+                            )
+                    debugLog(TAG, "[repository] registerCall: Call state updated to Registered")
+
+                    launch {
+                        currentCallEndpoint.collect {
+                            updateCurrentCall { copy(currentCallEndpoint = it) }
+                        }
+                    }
+                    launch {
+                        availableEndpoints.collect {
+                            updateCurrentCall { copy(availableCallEndpoints = it) }
+                        }
+                    }
+                    launch { isMuted.collect { updateCurrentCall { copy(isMuted = it) } } }
+                }
+                debugLog(
+                        TAG,
+                        "[repository] registerCall: Call successfully registered with Telecom SDK"
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "[repository] registerCall: Error registering call", e)
+                throw e
+            } finally {
+                debugLog(TAG, "[repository] registerCall: Call scope ended, setting state to None")
+                _currentCall.value = Call.None
+            }
+        }
+    }
+
+    override fun updateCall(
+            callId: String,
+            displayName: String,
+            address: Uri,
+            isVideo: Boolean,
+            displayOptions: Bundle?,
+    ) {
+        debugLog(
+                TAG,
+                "[repository] updateCall: Starting update - Name: $displayName, Address: $address, IsVideo: $isVideo"
+        )
+        super.updateCall(callId, displayName, address, isVideo, displayOptions)
+    }
+
+    private fun observeCallState(): Job {
+        return currentCall
+                .scan(Pair<Call?, Call>(null, currentCall.value)) { (_, prev), next ->
+                    Pair(prev, next)
+                }
+                .onEach { (previous, current) ->
+                    when {
+                        previous is Call.None && current is Call.Registered -> {
+                            if (!current.isIncoming()) {
+                                _listener?.onCallRegistered(current.id)
+                            }
+                        }
+                        previous is Call.Registered && current is Call.Registered -> {
+                            if (previous.isMuted != current.isMuted) {
+                                debugLog(
+                                        TAG,
+                                        "[repository] observeCallState: Mute changed: ${current.isMuted}"
+                                )
+                                _listener?.onMuteCallChanged(current.id, current.isMuted)
+                            }
+                            if (previous.currentCallEndpoint != current.currentCallEndpoint) {
+                                current.currentCallEndpoint?.let {
+                                    _listener?.onCallEndpointChanged(current.id, it.name.toString())
+                                }
+                            }
+                        }
+                    }
+                    _listener?.onCallStateChanged(current)
+                }
+                .launchIn(scope)
+    }
+
+    /** Collect the action source to handle client actions inside the call scope */
+    private suspend fun CallControlScope.processCallActions(actionSource: Flow<CallAction>) {
+        actionSource.collect { action ->
+            debugLog(TAG, "[repository] processCallActions: action: ${action::class.simpleName}")
+            when (action) {
+                is CallAction.Answer -> {
+                    doAnswer(action.isAudioCall)
+                }
+                is CallAction.Disconnect -> {
+                    doDisconnect(action)
+                }
+                is CallAction.SwitchAudioEndpoint -> {
+                    doSwitchEndpoint(action)
+                }
+                is CallAction.TransferCall -> {
+                    debugLog(
+                            TAG,
+                            "[repository] processCallActions: Transfer to endpoint: ${action.endpointId}"
+                    )
+                    val call = _currentCall.value as? Call.Registered
+                    val endpoints =
+                            call?.availableCallEndpoints?.firstOrNull {
+                                it.identifier == action.endpointId
+                            }
+                    if (endpoints != null) {
+                        requestEndpointChange(
+                                endpoint = endpoints,
+                        )
+                    } else {
+                        Log.w(
+                                TAG,
+                                "[repository] processCallActions: Endpoint not found for transfer, ignoring"
+                        )
+                    }
+                }
+                CallAction.Hold -> {
+                    when (val result = setInactive()) {
+                        is CallControlResult.Success -> {
+                            onIsCallInactive()
+                        }
+                        is CallControlResult.Error -> {
+                            Log.e(
+                                    TAG,
+                                    "[repository] processCallActions: Hold action failed with error code: ${result.errorCode}"
+                            )
+                            updateCurrentCall { copy(errorCode = result.errorCode) }
+                        }
+                    }
+                }
+                CallAction.Activate -> {
+                    when (val result = setActive()) {
+                        is CallControlResult.Success -> {
+                            onIsCallActive()
+                        }
+                        is CallControlResult.Error -> {
+                            Log.e(
+                                    TAG,
+                                    "[repository] processCallActions: Activate action failed with error code: ${result.errorCode}"
+                            )
+                            updateCurrentCall { copy(errorCode = result.errorCode) }
+                        }
+                    }
+                }
+                is CallAction.ToggleMute -> {
+                    // We cannot programmatically mute the telecom stack. Instead we just update
+                    // the state of the call and this will start/stop audio capturing.
+                    debugLog(TAG, "[repository] processCallActions: Toggling mute: ${action.isMute}")
+                    updateCurrentCall {
+                        val newMutedState = action.isMute
+                        copy(isMuted = newMutedState)
+                    }
+                }
+            }
+        }
+        debugLog(TAG, "[repository] processCallActions: Action collection ended")
+    }
+
+
+    private suspend fun CallControlScope.doSwitchEndpoint(action: CallAction.SwitchAudioEndpoint) {
+        debugLog(TAG, "[repository] doSwitchEndpoint: Switching to endpoint: ${action.endpointId}")
+        if (_currentCall.value !is Call.Registered) {
+            Log.w(TAG, "[repository] doSwitchEndpoint: Call not registered, ignoring")
+            return
+        }
+        // TODO once availableCallEndpoints is a state flow we can just get the value
+        val endpoints = (_currentCall.value as Call.Registered).availableCallEndpoints
+        // Switch to the given endpoint or fallback to the best possible one.
+        val newEndpoint = endpoints.firstOrNull { it.identifier == action.endpointId }
+
+        if (newEndpoint != null) {
+            debugLog(
+                    TAG,
+                    "[repository] doSwitchEndpoint: Found endpoint: ${newEndpoint.name}, requesting change"
+            )
+            requestEndpointChange(newEndpoint).also {
+                debugLog(TAG, "[repository] doSwitchEndpoint: Endpoint change result: $it")
+            }
+        } else {
+            Log.w(TAG, "[repository] doSwitchEndpoint: Endpoint not found in available endpoints")
+        }
+    }
+
+    private suspend fun CallControlScope.doDisconnect(action: CallAction.Disconnect) {
+        isSelfDisconnected = true
+        debugLog(TAG, "[repository] doDisconnect: Disconnecting call with cause: ${action.cause}")
+        disconnect(action.cause)
+        debugLog(TAG, "[repository] doDisconnect: Disconnect called, triggering onIsCallDisconnected")
+        onIsCallDisconnected(action.cause)
+    }
+
+    private suspend fun CallControlScope.doAnswer(isAudioCall: Boolean) {
+        isSelfAnswered = true
+        val callType =
+                if (isAudioCall) CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+                else CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+
+        when (val result = answer(callType)) {
+            is CallControlResult.Success -> {
+                onIsCallAnswered(callType)
+            }
+            is CallControlResult.Error -> {
+                Log.e(
+                        TAG,
+                        "[repository] doAnswer: Answer failed with error code: ${result.errorCode}"
+                )
+                isSelfAnswered = false
+                updateCurrentCall {
+                    Call.Unregistered(
+                            id = id,
+                            callAttributes = callAttributes,
+                            disconnectCause = DisconnectCause(DisconnectCause.BUSY),
+                    )
+                }
+            }
+        }
+    }
+
+    /**
+     * Can the call be successfully answered?? TIP: We would check the connection/call state to see
+     * if we can answer a call Example you may need to wait for another call to hold.
+     */
+    val onIsCallAnswered: suspend (type: Int) -> Unit = {
+        debugLog(
+                TAG,
+                "[repository] onIsCallAnswered: Call answered, type: $it, isSelfAnswered: $isSelfAnswered"
+        )
+        updateCurrentCall { copy(isActive = true, isOnHold = false) }
+
+        val call = _currentCall.value
+        val source =
+                if (isSelfAnswered) EventSource.APP
+                else EventSource.SYS
+        if (call is Call.Registered) {
+            _listener?.onIsCallAnswered(call.id, source)
+        }
+        isSelfAnswered = false
+        debugLog(TAG, "[repository] onIsCallAnswered: Call state updated to active")
+    }
+
+    /** Can the call perform a disconnect */
+    val onIsCallDisconnected: suspend (cause: DisconnectCause) -> Unit = {
+        debugLog(
+                TAG,
+                "[repository] onIsCallDisconnected: Call disconnected, cause: ${it.reason}, description: ${it.description}"
+        )
+        val source =
+                if (isSelfDisconnected) EventSource.APP
+                else EventSource.SYS
+        var callId: String? = null
+        if (_currentCall.value is Call.Registered) {
+            callId = (_currentCall.value as Call.Registered).id
+        }
+
+        updateCurrentCall { Call.Unregistered(id, callAttributes, it) }
+        _listener?.onIsCallDisconnected(callId, it, source)
+        isSelfDisconnected = false
+        debugLog(TAG, "[repository] onIsCallDisconnected: Call state updated to Unregistered")
+    }
+
+    /**
+     * Check is see if we can make the call active. Other calls and state might stop us from
+     * activating the call
+     */
+    val onIsCallActive: suspend () -> Unit = {
+        debugLog(TAG, "[repository] onIsCallActive: Call became active")
+        updateCurrentCall {
+            copy(
+                    errorCode = null,
+                    isActive = true,
+                    isOnHold = false,
+            )
+        }
+
+        val call = _currentCall.value
+        if (call is Call.Registered) {
+            _listener?.onIsCallActive(call.id)
+        }
+        debugLog(TAG, "[repository] onIsCallActive: Call state updated")
+    }
+
+    /** Check to see if we can make the call inactivate */
+    val onIsCallInactive: suspend () -> Unit = {
+        debugLog(TAG, "[repository] onIsCallInactive: Call became inactive (on hold)")
+        updateCurrentCall { copy(errorCode = null, isOnHold = true) }
+
+        val call = _currentCall.value
+        if (call is Call.Registered) {
+            _listener?.onIsCallInactive(call.id)
+        }
+        debugLog(TAG, "[repository] onIsCallInactive: Call state updated to on hold")
+    }
+
+}

package/android/src/main/res/drawable/ic_phone_paused_24.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:autoMirrored="true"
+    android:tint="#000000"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M16,3c-0.55,0 -1,0.45 -1,1v5c0,0.55 0.45,1 1,1s1,-0.45 1,-1L17,4c0,-0.55 -0.45,-1 -1,-1zM19,4v5c0,0.55 0.45,1 1,1s1,-0.45 1,-1L21,4c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1zM19.23,15.26l-2.54,-0.29c-0.61,-0.07 -1.21,0.14 -1.64,0.57l-1.84,1.84c-2.83,-1.44 -5.15,-3.75 -6.59,-6.59l1.85,-1.85c0.43,-0.43 0.64,-1.03 0.57,-1.64l-0.29,-2.52c-0.12,-1.01 -0.97,-1.77 -1.99,-1.77L5.03,3.01c-1.13,0 -2.07,0.94 -2,2.07 0.53,8.54 7.36,15.36 15.89,15.89 1.13,0.07 2.07,-0.87 2.07,-2v-1.73c0.01,-1.01 -0.75,-1.86 -1.76,-1.98z" />
+</vector>

package/android/src/main/res/drawable/ic_round_call_24.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:autoMirrored="true"
+    android:tint="#000000"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M19.23,15.26l-2.54,-0.29c-0.61,-0.07 -1.21,0.14 -1.64,0.57l-1.84,1.84c-2.83,-1.44 -5.15,-3.75 -6.59,-6.59l1.85,-1.85c0.43,-0.43 0.64,-1.03 0.57,-1.64l-0.29,-2.52c-0.12,-1.01 -0.97,-1.77 -1.99,-1.77H5.03c-1.13,0 -2.07,0.94 -2,2.07 0.53,8.54 7.36,15.36 15.89,15.89 1.13,0.07 2.07,-0.87 2.07,-2v-1.73c0.01,-1.01 -0.75,-1.86 -1.76,-1.98z" />
+</vector>

package/android/src/main/res/drawable/ic_user.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+     Copyright (c) 2024 Stream.io Inc. All rights reserved.
+
+     Licensed under the Stream License;
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          https://github.com/GetStream/stream-video-android/blob/main/LICENSE
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#CCC"
+        android:pathData="M480,0a480,480 0 1,0 0,960a480,480 0 1,0 0,-960" />
+    <path
+        android:fillColor="#434343"
+        android:pathData="M480,480q-66,0 -113,-47t-47,-113q0,-66 47,-113t113,-47q66,0 113,47t47,113q0,66 -47,113t-113,47ZM160,720v-32q0,-34 17.5,-62.5T224,582q62,-31 126,-46.5T480,520q66,0 130,15.5T736,582q29,15 46.5,43.5T800,688v32q0,33 -23.5,56.5T720,800L240,800q-33,0 -56.5,-23.5T160,720Z" />
+</vector>

package/dist/module/CallingxModule.js

@@ -0,0 +1,191 @@
+"use strict";
+
+import { Platform } from 'react-native';
+import NativeCallingModule from "./spec/NativeCallingx.js";
+import { checkCallPermissions, requestCallPermissions } from "./utils/permissions.js";
+import { HEADLESS_TASK_NAME, registerHeadlessTask, setHeadlessTask } from "./utils/headlessTask.js";
+import { EventManager } from "./EventManager.js";
+import { androidEndCallReasonMap, defaultAndroidOptions, defaultiOSOptions, defaultTextTransformer, iosEndCallReasonMap } from "./utils/constants.js";
+import { isVoipEvent } from "./utils/utils.js";
+class CallingxModule {
+  _isNotificationsAllowed = false;
+  _isSetup = false;
+  _isOngoingCallsEnabled = false;
+  _isHeadlessTaskRegistered = false;
+  titleTransformer = text => text;
+  subtitleTransformer = undefined;
+  eventManager = new EventManager();
+  voipEventManager = new EventManager();
+  get isNotificationsAllowed() {
+    if (Platform.OS !== 'android') {
+      return true;
+    }
+    return this._isNotificationsAllowed && NativeCallingModule.canPostNotifications();
+  }
+  get isOngoingCallsEnabled() {
+    return this._isOngoingCallsEnabled;
+  }
+  get isSetup() {
+    return this._isSetup;
+  }
+  setup(options) {
+    if (this._isSetup) {
+      return;
+    }
+    this._isOngoingCallsEnabled = options.enableOngoingCalls ?? false;
+    this.setShouldRejectCallWhenBusy(options.shouldRejectCallWhenBusy ?? false);
+    if (Platform.OS === 'ios') {
+      NativeCallingModule.setupiOS({
+        ...defaultiOSOptions,
+        ...options.ios
+      });
+    }
+    if (Platform.OS === 'android') {
+      const {
+        titleTransformer,
+        subtitleTransformer,
+        incomingChannel,
+        ongoingChannel
+      } = options.android ?? {};
+      this.titleTransformer = titleTransformer ?? defaultTextTransformer;
+      this.subtitleTransformer = subtitleTransformer;
+      const notificationsConfig = {
+        incomingChannel: {
+          ...defaultAndroidOptions.incomingChannel,
+          ...(incomingChannel ?? {})
+        },
+        ongoingChannel: {
+          ...defaultAndroidOptions.ongoingChannel,
+          ...(ongoingChannel ?? {})
+        }
+      };
+      if (notificationsConfig.incomingChannel.id === notificationsConfig.ongoingChannel.id) {
+        throw new Error('Incoming and outgoing channel IDs cannot be the same');
+      }
+      NativeCallingModule.setupAndroid(notificationsConfig);
+      registerHeadlessTask();
+    }
+    this._isSetup = true;
+  }
+  setShouldRejectCallWhenBusy(shouldReject) {
+    NativeCallingModule.setShouldRejectCallWhenBusy(shouldReject);
+  }
+  async requestPermissions() {
+    const result = await requestCallPermissions();
+    this._isNotificationsAllowed = result.postNotifications;
+    return result;
+  }
+  async checkPermissions() {
+    const result = await checkCallPermissions();
+    this._isNotificationsAllowed = result.postNotifications;
+    return result;
+  }
+  getInitialEvents() {
+    return NativeCallingModule.getInitialEvents();
+  }
+  getInitialVoipEvents() {
+    return NativeCallingModule.getInitialVoipEvents();
+  }
+
+  //activates call that was registered with the telecom stack
+  setCurrentCallActive(callId) {
+    return NativeCallingModule.setCurrentCallActive(callId);
+  }
+  displayIncomingCall(callId, phoneNumber, callerName, hasVideo) {
+    const displayOptions = {
+      displayTitle: this.titleTransformer(callerName, true),
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, true)
+    };
+    return NativeCallingModule.displayIncomingCall(callId, phoneNumber, callerName, hasVideo, displayOptions);
+  }
+  answerIncomingCall(callId) {
+    return NativeCallingModule.answerIncomingCall(callId);
+  }
+
+  //registers call with the telecom stack
+  startCall(callId, phoneNumber, callerName, hasVideo) {
+    const displayOptions = {
+      displayTitle: this.titleTransformer(callerName, false),
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, false)
+    };
+    return NativeCallingModule.startCall(callId, phoneNumber, callerName, hasVideo, displayOptions);
+  }
+  updateDisplay(callId, phoneNumber, callerName) {
+    const displayOptions = {
+      displayTitle: this.titleTransformer(callerName, false),
+      //adjust incoming or outgoing call
+      displaySubtitle: this.subtitleTransformer?.(phoneNumber, false) //adjust incoming or outgoing call
+    };
+    return NativeCallingModule.updateDisplay(callId, phoneNumber, callerName, displayOptions);
+  }
+  endCallWithReason(callId, reason) {
+    const reasons = Platform.OS === 'ios' ? iosEndCallReasonMap : androidEndCallReasonMap;
+    if (Platform.OS === 'ios' && reason === 'local') {
+      return NativeCallingModule.endCall(callId);
+    }
+    return NativeCallingModule.endCallWithReason(callId, reasons[reason]);
+  }
+  isCallRegistered(callId) {
+    return NativeCallingModule.isCallRegistered(callId);
+  }
+  hasRegisteredCall() {
+    return NativeCallingModule.hasRegisteredCall();
+  }
+  setMutedCall(callId, isMuted) {
+    return NativeCallingModule.setMutedCall(callId, isMuted);
+  }
+  setOnHoldCall(callId, isOnHold) {
+    return NativeCallingModule.setOnHoldCall(callId, isOnHold);
+  }
+  registerBackgroundTask(taskProvider) {
+    const stopTask = () => {
+      this._isHeadlessTaskRegistered = false;
+      NativeCallingModule.stopBackgroundTask(HEADLESS_TASK_NAME);
+    };
+    setHeadlessTask(taskData => taskProvider(taskData, stopTask));
+    this._isHeadlessTaskRegistered = true;
+    NativeCallingModule.registerBackgroundTaskAvailable();
+  }
+  async startBackgroundTask(taskProvider) {
+    // If taskProvider is provided, register it first
+    if (taskProvider) {
+      this.registerBackgroundTask(taskProvider);
+    }
+
+    // Check if task is registered
+    if (!this._isHeadlessTaskRegistered) {
+      throw new Error('Background task not registered. Call registerBackgroundTask first.');
+    }
+
+    // Check if service is started (Android only)
+    if (Platform.OS === 'android') {
+      const isServiceStarted = await NativeCallingModule.isServiceStarted();
+      if (!isServiceStarted) {
+        throw new Error('Service is not started. Call displayIncomingCall or startCall first.');
+      }
+    }
+    return NativeCallingModule.startBackgroundTask(HEADLESS_TASK_NAME, 0);
+  }
+  stopBackgroundTask() {
+    this._isHeadlessTaskRegistered = false;
+    return NativeCallingModule.stopBackgroundTask(HEADLESS_TASK_NAME);
+  }
+  registerVoipToken() {
+    NativeCallingModule.registerVoipToken();
+  }
+  addEventListener(eventName, callback) {
+    const manager = isVoipEvent(eventName) ? this.voipEventManager : this.eventManager;
+    manager.addListener(eventName, callback);
+    return {
+      remove: () => {
+        manager.removeListener(eventName, callback);
+      }
+    };
+  }
+  log(message, level) {
+    NativeCallingModule.log(message, level);
+  }
+}
+const module = new CallingxModule();
+export default module;
+//# sourceMappingURL=CallingxModule.js.map