@stream-io/react-native-callingx 0.1.1-beta.1 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+
+## [0.1.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/react-native-callingx-0.1.0...@stream-io/react-native-callingx-0.1.1) (2026-04-09)
+
+### Bug Fixes
+
+- callingx docs update ([#2195](https://github.com/GetStream/stream-video-js/issues/2195)) ([7a6b632](https://github.com/GetStream/stream-video-js/commit/7a6b632270ec1187236a0e4e5c5396a98a20fd16))
+
+## 0.1.0 (2026-04-09)
+
+### Features
+
+- callkit/telecom integration ([#2028](https://github.com/GetStream/stream-video-js/issues/2028)) ([d579acd](https://github.com/GetStream/stream-video-js/commit/d579acd1975fb4945e40452b27e372694c737628))

package/README.md

@@ -1,395 +1,83 @@
-# react-native-callingx
+# @stream-io/react-native-callingx
 
-A React Native Turbo Module for seamless native calling integration. This library provides a unified API to integrate with **CallKit** on iOS and the **Telecom/ConnectionService** API on Android, enabling your app to display system-level calling UI and interact with native call controls.
+React Native native-calling bridge for:
 
-## Features
+- iOS CallKit
+- Android Telecom/ConnectionService
 
-- 📞 **Incoming call UI** — Display native incoming call screens (even when the app is killed)
-- 📲 **Outgoing call registration** — Register outgoing calls with the system
-- 🎛️ **Call controls** — Mute, hold, end calls with native system integration
-- 🔔 **Custom notifications** — Configurable Android notification channels
-- ⚡ **Turbo Module** — Built with the New Architecture for optimal performance
-- 📱 **Background support** — Handle calls when the app is backgrounded or killed
-
-## Requirements
-
-- React Native 0.73+ (New Architecture / Turbo Modules)
-- iOS 13.0+
-- Android API 26+ (Android 8.0 Oreo)
-
-## Installation
+## Install
 
 ```sh
-npm install @stream-io/react-native-callingx
-# or
 yarn add @stream-io/react-native-callingx
 ```
 
-### iOS Setup
-
-1. Add the required background modes to your `Info.plist`:
-
-```xml
-<key>UIBackgroundModes</key>
-<array>
-  <string>voip</string>
-  <string>audio</string>
-</array>
-```
-
-2. Run pod install:
+Then run iOS pods:
 
 ```sh
 cd ios && pod install
 ```
 
-3. For VoIP push notifications, configure your `AppDelegate` to report incoming calls:
-
-```objc
-#import <Callingx/CallingxPublic.h>
-
-- (void)pushRegistry:(PKPushRegistry *)registry
-didReceiveIncomingPushWithPayload:(PKPushPayload *)payload
-             forType:(PKPushType)type
-withCompletionHandler:(void (^)(void))completion {
-
-    // Extract call information from payload
-    NSString *callId = payload.dictionaryPayload[@"call_id"];
-    NSString *callerName = payload.dictionaryPayload[@"caller_name"];
-    NSString *handle = payload.dictionaryPayload[@"handle"];
-    BOOL hasVideo = [payload.dictionaryPayload[@"has_video"] boolValue];
-
-    [Callingx reportNewIncomingCall:callId
-                             handle:handle
-                         handleType:@"generic"
-                           hasVideo:hasVideo
-                localizedCallerName:callerName
-                    supportsHolding:YES
-                       supportsDTMF:NO
-                   supportsGrouping:NO
-                 supportsUngrouping:NO
-                            payload:payload.dictionaryPayload
-              withCompletionHandler:completion];
-}
-```
-
-### Android Setup
+## Quick start
 
-## Usage
+```ts
+import { CallingxModule } from '@stream-io/react-native-callingx';
 
-### Setup
-
-Initialize the module with platform-specific configuration:
-
-```typescript
-import { CallingxModule } from 'react-native-callingx';
-
-// Setup must be called before any other method
 CallingxModule.setup({
   ios: {
-    appName: 'My App',
     supportsVideo: true,
-    maximumCallsPerCallGroup: 1,
-    maximumCallGroups: 1,
-    handleType: 'generic', // 'generic' | 'number' | 'phone' | 'email'
+    callsHistory: false,
   },
   android: {
     incomingChannel: {
-      id: 'incoming_calls',
-      name: 'Incoming Calls',
-      sound: 'ringtone', // optional custom sound
-      vibration: true,
+      id: 'incoming_calls_channel',
+      name: 'Incoming calls',
     },
-    outgoingChannel: {
-      id: 'ongoing_calls',
-      name: 'Ongoing Calls',
-    },
-    // Optional: transform display text
-    titleTransformer: (name) => `Call from ${name}`,
-    subtitleTransformer: (phoneNumber) => phoneNumber,
   },
 });
-```
-
-### Request Permissions
 
-Before displaying calls, request the required permissions:
-
-```typescript
-const permissions = await CallingxModule.requestPermissions();
-console.log('Audio permission:', permissions.recordAudio);
-console.log('Notification permission:', permissions.postNotifications);
-```
-
-### Display Incoming Call
-
-Show the native incoming call UI:
-
-```typescript
 await CallingxModule.displayIncomingCall(
-  'unique-call-id',
-  '+1234567890', // phone number / handle
-  'John Doe', // caller name
-  true, // has video
-);
-```
-
-### Start Outgoing Call
-
-Register an outgoing call with the system:
-
-```typescript
-await CallingxModule.startCall(
-  'unique-call-id',
-  '+1234567890',
+  'call-id',
+  '+123456789',
   'John Doe',
-  false, // audio only
+  true,
 );
 ```
 
-### Answer Call
-
-Answer an incoming call programmatically:
-
-```typescript
-await CallingxModule.answerIncomingCall('unique-call-id');
-```
-
-### Activate Call
-
-Mark a call as active (connected):
-
-```typescript
-await CallingxModule.setCurrentCallActive('unique-call-id');
-```
-
-### End Call
-
-End a call with a specific reason:
-
-```typescript
-import type { EndCallReason } from 'react-native-callingx';
-
-// Available reasons:
-//   'local' | 'remote' | 'rejected' | 'busy' | 'answeredElsewhere' |
-//   'missed' | 'error' | 'canceled' | 'restricted' | 'unknown'
-await CallingxModule.endCallWithReason('unique-call-id', 'remote');
-```
-
-### Mute/Unmute
-
-Toggle call mute state:
-
-```typescript
-await CallingxModule.setMutedCall('unique-call-id', true); // mute
-await CallingxModule.setMutedCall('unique-call-id', false); // unmute
-```
-
-### Hold/Unhold
-
-Toggle call hold state:
-
-```typescript
-await CallingxModule.setOnHoldCall('unique-call-id', true); // hold
-await CallingxModule.setOnHoldCall('unique-call-id', false); // unhold
-```
-
-### Update Display
-
-Update the caller information during a call:
-
-```typescript
-await CallingxModule.updateDisplay(
-  'unique-call-id',
-  '+1234567890',
-  'Updated Name',
-);
-```
-
-### Event Listeners
-
-Subscribe to call events:
-
-```typescript
-import { CallingxModule } from 'react-native-callingx';
-import type { EventName } from 'react-native-callingx';
-
-// Answer event - user answered from system UI
-const answerSubscription = CallingxModule.addEventListener(
-  'answerCall',
-  (params) => {
-    console.log('Call answered:', params.callId);
-  },
-);
-
-// End event - call ended
-const endSubscription = CallingxModule.addEventListener('endCall', (params) => {
-  console.log('Call ended:', params.callId, 'Cause:', params.cause);
-});
-
-// Hold toggle event
-const holdSubscription = CallingxModule.addEventListener(
-  'didToggleHoldCallAction',
-  (params) => {
-    console.log('Hold toggled:', params.callId, 'On hold:', params.hold);
-  },
-);
-
-// Mute toggle event
-const muteSubscription = CallingxModule.addEventListener(
-  'didPerformSetMutedCallAction',
-  (params) => {
-    console.log('Mute toggled:', params.callId, 'Muted:', params.muted);
-  },
-);
-
-// Start call action (outgoing call initiated from system)
-const startSubscription = CallingxModule.addEventListener(
-  'didReceiveStartCallAction',
-  (params) => {
-    console.log('Start call action:', params.callId);
-  },
-);
-
-// Clean up when done
-answerSubscription.remove();
-endSubscription.remove();
-// ... remove other subscriptions
-```
-
-### Handle Initial Events
-
-When the app is launched from a killed state by a call action, retrieve queued events:
-
-```typescript
-// Get events that occurred before the module was initialized
-const initialEvents = CallingxModule.getInitialEvents();
-initialEvents.forEach((event) => {
-  console.log('Initial event:', event.eventName, event.params);
-});
-
-// Clear initial events after processing
-await CallingxModule.clearInitialEvents();
-```
-
-### Background Tasks (Android)
-
-Run background tasks for call-related operations:
-
-```typescript
-// Start a managed background task
-await CallingxModule.startBackgroundTask(async (taskData, stopTask) => {
-  try {
-    // Perform background work (e.g., connect to call server)
-    await connectToCallServer();
-  } finally {
-    stopTask(); // Always call when done
-  }
-});
-
-// Or stop manually
-await CallingxModule.stopBackgroundTask();
-```
-
-## API Reference
-
-### CallingxModule
-
-| Method                                                           | Description                                          |
-| ---------------------------------------------------------------- | ---------------------------------------------------- |
-| `setup(options)`                                                 | Initialize the module with platform-specific options |
-| `requestPermissions()`                                           | Request required permissions (audio, notifications)  |
-| `checkPermissions()`                                             | Check current permission status                      |
-| `displayIncomingCall(callId, phoneNumber, callerName, hasVideo)` | Display incoming call UI                             |
-| `answerIncomingCall(callId)`                                     | Answer an incoming call                              |
-| `startCall(callId, phoneNumber, callerName, hasVideo)`           | Register an outgoing call                            |
-| `setCurrentCallActive(callId)`                                   | Mark call as active/connected                        |
-| `updateDisplay(callId, phoneNumber, callerName)`                 | Update caller display info                           |
-| `endCallWithReason(callId, reason)`                              | End call with specified reason                       |
-| `setMutedCall(callId, isMuted)`                                  | Toggle call mute state                               |
-| `setOnHoldCall(callId, isOnHold)`                                | Toggle call hold state                               |
-| `addEventListener(eventName, callback)`                          | Subscribe to call events                             |
-| `getInitialEvents()`                                             | Get queued events from app launch                    |
-| `clearInitialEvents()`                                           | Clear queued initial events                          |
-| `startBackgroundTask(taskProvider)`                              | Start Android background task                        |
-| `stopBackgroundTask()`                                           | Stop Android background task                         |
-| `log(message, level)`                                            | Log message to native console                        |
-
-### Events
-
-| Event                          | Parameters          | Description                       |
-| ------------------------------ | ------------------- | --------------------------------- |
-| `answerCall`                   | `{ callId }`        | User answered call from system UI |
-| `endCall`                      | `{ callId, cause }` | Call ended                        |
-| `didToggleHoldCallAction`      | `{ callId, hold }`  | Hold state changed                |
-| `didPerformSetMutedCallAction` | `{ callId, muted }` | Mute state changed                |
-| `didReceiveStartCallAction`    | `{ callId }`        | Outgoing call action received     |
-
-### Types
-
-```typescript
-type EndCallReason =
-  | 'local' // Call ended by the local user (e.g., hanging up)
-  | 'remote' // Call ended by the remote party, or outgoing not answered
-  | 'rejected' // Call was rejected/declined
-  | 'busy' // Remote party was busy
-  | 'answeredElsewhere' // Answered on another device
-  | 'missed' // No response to an incoming call
-  | 'error' // Call failed due to an error (e.g., network issue)
-  | 'canceled' // Call canceled before the remote party could answer
-  | 'restricted' // Call restricted (e.g., airplane mode)
-  | 'unknown'; // Unknown or unspecified disconnect reason
-
-type CallingExpiOSOptions = {
-  appName: string;
-  supportsVideo?: boolean;
-  maximumCallsPerCallGroup?: number;
-  maximumCallGroups?: number;
-  handleType?: 'generic' | 'number' | 'phone' | 'email';
-};
-
-type CallingExpAndroidOptions = {
-  incomingChannel?: {
-    id: string;
-    name: string;
-    sound?: string;
-    vibration?: boolean;
-  };
-  outgoingChannel?: {
-    id: string;
-    name: string;
-    sound?: string;
-    vibration?: boolean;
-  };
-};
-
-type PermissionsResult = {
-  recordAudio: boolean;
-  postNotifications: boolean;
-};
-```
-
-## Troubleshooting
-
-### iOS
-
-- **Incoming call not showing**: Ensure `voip` background mode is enabled and VoIP push certificate is configured
-- **CallKit errors**: Check that `appName` is set in setup options
-- **Audio issues**: The module automatically configures the audio session, but ensure no conflicts with other audio libraries
+## Main APIs
 
-### Android
+- `setup(options)` - required before any call action.
+- `displayIncomingCall(callId, phoneNumber, callerName, hasVideo)`.
+- `startCall(callId, phoneNumber, callerName, hasVideo)`.
+- `setCurrentCallActive(callId)`.
+- `updateDisplay(callId, phoneNumber, callerName, incoming)`.
+- `endCallWithReason(callId, reason)`.
+- `setMutedCall(callId, isMuted)`.
+- `setOnHoldCall(callId, isOnHold)`.
+- `addEventListener(eventName, callback)`.
+- `getInitialEvents()` and `getInitialVoipEvents()`.
+- `registerBackgroundTask(taskProvider)` / `startBackgroundTask()` / `stopBackgroundTask()` (Android).
 
-- **Notifications not showing**: Check POST_NOTIFICATIONS permission on Android 13+
-- **Call not answered on tap**: Ensure `handleCallingIntent` is called in both `onCreate` and `onNewIntent` in your MainActivity
+## Event names
 
-## Contributing
+Call events:
 
-See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+- `answerCall`
+- `endCall`
+- `didDisplayIncomingCall`
+- `didToggleHoldCallAction`
+- `didPerformSetMutedCallAction`
+- `didChangeAudioRoute`
+- `didReceiveStartCallAction`
+- `didActivateAudioSession`
+- `didDeactivateAudioSession`
 
-## License
+VoIP events:
 
-MIT
+- `voipNotificationsRegistered`
+- `voipNotificationReceived`
 
----
+## Notes
 
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+- Import from `@stream-io/react-native-callingx`.
+- iOS-only helpers: `registerVoipToken`, `fulfillAnswerCallAction`, `fulfillEndCallAction`.
+- Android helpers: `canPostNotifications`, `isOngoingCallsEnabled`.

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

@@ -48,6 +48,8 @@ class CallService : Service(), CallRepository.Listener {
     companion object {
         private const val TAG = "[Callingx] CallService"
 
+        internal const val DEFAULT_DISPLAY_NAME = "Unknown Caller"
+
         internal const val EXTRA_CALL_ID = "extra_call_id"
         internal const val EXTRA_NAME = "extra_name"
         internal const val EXTRA_URI = "extra_uri"
@@ -104,8 +106,12 @@ class CallService : Service(), CallRepository.Listener {
                 )
                 return
             }
+            
+            val createdById = data["created_by_id"]
+            val createdName = data["created_by_display_name"].orEmpty()
+            val displayName = data["call_display_name"].orEmpty()
+            val callDisplayName = displayName.ifEmpty { createdName.ifEmpty { DEFAULT_DISPLAY_NAME } }
 
-            val callName = data["created_by_display_name"].orEmpty()
             val isVideo = data["video"] == "true"
 
             CallRegistrationStore.trackCallRegistration(callCid, null)
@@ -114,8 +120,8 @@ class CallService : Service(), CallRepository.Listener {
                     Intent(context, CallService::class.java).apply {
                         action = ACTION_INCOMING_CALL
                         putExtra(EXTRA_CALL_ID, callCid)
-                        putExtra(EXTRA_URI, callCid.toUri())
-                        putExtra(EXTRA_NAME, callName)
+                        putExtra(EXTRA_URI, createdById?.toUri() ?: callDisplayName.toUri())
+                        putExtra(EXTRA_NAME, callDisplayName)
                         putExtra(EXTRA_IS_VIDEO, isVideo)
                     }
 

package/android/src/main/java/io/getstream/rn/callingx/notifications/CallNotificationManager.kt

@@ -317,25 +317,19 @@ class CallNotificationManager(
         if (call.isIncoming() && !call.isActive && optimisticState == OptimisticState.NONE) {
             return NotificationCompat.CallStyle.forIncomingCall(
                     caller,
-                    NotificationIntentFactory.getPendingBroadcastIntent(
-                            context,
-                            CallingxModuleImpl.CALL_END_ACTION,
-                            call.id
-                    ) {
-                        putExtra(
-                                CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
-                                getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
-                        )
-                        putExtra(
-                                CallingxModuleImpl.EXTRA_SOURCE,
-                                CallRepository.EventSource.SYS.name.lowercase()
-                        )
-                    },
+                    NotificationIntentFactory.getPendingNotificationIntent(
+                        context,
+                        CallingxModuleImpl.CALL_END_ACTION,
+                        call.id,
+                        CallRepository.EventSource.SYS.name.lowercase(),
+                        false
+                    ),
                     NotificationIntentFactory.getPendingNotificationIntent(
                             context,
                             CallingxModuleImpl.CALL_ANSWERED_ACTION,
                             call.id,
-                            CallRepository.EventSource.SYS.name.lowercase()
+                            CallRepository.EventSource.SYS.name.lowercase(),
+                            true
                     )
             )
         }

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationIntentFactory.kt

@@ -22,10 +22,11 @@ object NotificationIntentFactory {
     context: Context,
     action: String,
     callId: String,
-    source: String
+    source: String,
+    includeLaunchActivity: Boolean
   ): PendingIntent {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-      getReceiverActivityIntent(context, action, callId, source)
+      getReceiverActivityIntent(context, action, callId, source, includeLaunchActivity)
     } else {
       getPendingServiceIntent(context, action, callId, source)
     }
@@ -47,7 +48,7 @@ object NotificationIntentFactory {
     )
   }
 
-  fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+  fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String, includeLaunchActivity: Boolean): PendingIntent {
     val receiverIntent =
       Intent(context, NotificationReceiverActivity::class.java).apply {
         this.action = action
@@ -57,14 +58,25 @@ object NotificationIntentFactory {
 
     val launchActivity = context.packageManager.getLaunchIntentForPackage(context.packageName)
     val launchActivityIntent =
-      Intent(launchActivity).apply {
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      launchActivity?.let { base ->
+        Intent(base).apply {
+          addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        }
+      }
+
+    // intents are started in order and build a synthetic back stack
+    // the last intent is the one on top, so the launch activity should come first
+    val intents =
+      if (includeLaunchActivity && launchActivityIntent != null) {
+        arrayOf(launchActivityIntent, receiverIntent)
+      } else {
+        arrayOf(receiverIntent)
       }
 
     return PendingIntent.getActivities(
       context,
       requestCodeFor(callId, REQUEST_CODE_RECEIVER_ACTIVITY),
-      arrayOf(launchActivityIntent, receiverIntent),
+      intents,
       PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
     )
   }

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationReceiverActivity.kt

@@ -3,8 +3,10 @@ package io.getstream.rn.callingx.notifications
 import android.app.Activity
 import android.content.Intent
 import android.os.Bundle
+import android.telecom.DisconnectCause
 import io.getstream.rn.callingx.CallingxModuleImpl
 import io.getstream.rn.callingx.debugLog
+import io.getstream.rn.callingx.getDisconnectCauseString
 
 // For Android 12+
 class NotificationReceiverActivity : Activity() {
@@ -21,33 +23,54 @@ class NotificationReceiverActivity : Activity() {
     finish()
   }
 
-  //re-send intent from notification to the turbo module
   private fun handleIntent(intent: Intent?) {
-    if (intent == null) {
-      return
+    val nonNullIntent = intent ?: return
+    val action = nonNullIntent.action ?: return
+
+    when (action) {
+      CallingxModuleImpl.CALL_ANSWERED_ACTION -> onCallAnswered(nonNullIntent)
+      CallingxModuleImpl.CALL_END_ACTION -> onCallEnded(nonNullIntent)
     }
+  }
 
-    if (intent.action == CallingxModuleImpl.CALL_ANSWERED_ACTION) {
-      debugLog("[Callingx] NotificationReceiverActivity", "[receiver] answered call action")
-      val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
-      val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
-
-      if (callId != null) {
-        Intent(CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION)
-          .apply {
-            setPackage(packageName)
-            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
-          }
-          .also { sendBroadcast(it) }
-      }
+  private fun onCallAnswered(intent: Intent) {
+    debugLog("[Callingx] NotificationReceiverActivity", "[receiver] answered call action")
+    val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
+    val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
 
-      Intent(CallingxModuleImpl.CALL_ANSWERED_ACTION)
+    if (callId != null) {
+      Intent(CallingxModuleImpl.CALL_OPTIMISTIC_ACCEPT_ACTION)
         .apply {
           setPackage(packageName)
           putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
-          putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
         }
         .also { sendBroadcast(it) }
     }
+
+    Intent(CallingxModuleImpl.CALL_ANSWERED_ACTION)
+      .apply {
+        setPackage(packageName)
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
+      }
+      .also { sendBroadcast(it) }
+  }
+
+  private fun onCallEnded(intent: Intent) {
+    debugLog("[Callingx] NotificationReceiverActivity", "[receiver] rejected call action")
+    val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
+    val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
+
+    Intent(CallingxModuleImpl.CALL_END_ACTION)
+      .apply {
+        setPackage(packageName)
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
+        putExtra(
+          CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
+          getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
+        )
+      }
+      .also { sendBroadcast(it) }
   }
 }

package/android/src/main/java/io/getstream/rn/callingx/notifications/NotificationReceiverService.kt

@@ -3,8 +3,10 @@ package io.getstream.rn.callingx.notifications
 import android.app.Service
 import android.content.Intent
 import android.os.IBinder
+import android.telecom.DisconnectCause
 import android.util.Log
 import io.getstream.rn.callingx.CallingxModuleImpl
+import io.getstream.rn.callingx.getDisconnectCauseString
 
 class NotificationReceiverService : Service() {
 
@@ -23,6 +25,7 @@ class NotificationReceiverService : Service() {
 
     when (action) {
       CallingxModuleImpl.CALL_ANSWERED_ACTION -> onCallAnswered(intent)
+      CallingxModuleImpl.CALL_END_ACTION -> onCallEnded(intent)
     }
 
     stopSelf(startId)
@@ -60,4 +63,25 @@ class NotificationReceiverService : Service() {
       }
     }
   }
+
+  /** Mirrors [NotificationReceiverActivity] on API levels below 33 where the service receives notification actions. */
+  private fun onCallEnded(intent: Intent) {
+    val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
+    val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
+    try {
+      Intent(CallingxModuleImpl.CALL_END_ACTION)
+        .apply {
+          setPackage(packageName)
+          putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+          putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
+          putExtra(
+            CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
+            getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
+          )
+        }
+        .also { sendBroadcast(it) }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error sending call end intent", e)
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/react-native-callingx",
-  "version": "0.1.1-beta.1",
+  "version": "0.1.1",
   "description": "CallKit and Telecom API capabilities for React Native",
   "main": "./dist/module/index.js",
   "module": "./dist/module/index.js",
@@ -61,7 +61,7 @@
   "devDependencies": {
     "@react-native-community/cli": "20.0.1",
     "@react-native/babel-preset": "^0.81.5",
-    "@stream-io/react-native-webrtc": "137.1.2",
+    "@stream-io/react-native-webrtc": "137.1.3",
     "@types/react": "^19.1.0",
     "del-cli": "^6.0.0",
     "react": "19.1.0",