diff --git a/package.json b/package.json
index 728516a943..fc53e721cb 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,7 @@
"start:react-native:ios:dogfood": "yarn workspace @stream-io/video-react-native-dogfood run ios",
"start:react-native:android:dogfood": "yarn workspace @stream-io/video-react-native-dogfood run android",
"build:styling": "yarn workspace @stream-io/video-styling run build",
+ "build:callingx": "yarn workspace react-native-callingx run build",
"start:styling": "yarn workspace @stream-io/video-styling run start",
"build:client": "yarn workspace @stream-io/video-client run build",
"start:client": "yarn workspace @stream-io/video-client run start",
@@ -30,7 +31,7 @@
"build:video-filters-react-native": "yarn workspace @stream-io/video-filters-react-native run build",
"build:noise-cancellation-react-native": "yarn workspace @stream-io/noise-cancellation-react-native run build",
"build:react:deps": "yarn build:client && yarn build:styling && yarn build:react:bindings && yarn build:video-filters-web && yarn build:audio-filters-web && yarn build:react:sdk",
- "build:react-native:deps": "yarn build:client && yarn build:react:bindings && yarn build:video-filters-react-native && yarn build:noise-cancellation-react-native && yarn build:react-native:sdk",
+ "build:react-native:deps": "yarn build:client && yarn build:react:bindings && yarn build:video-filters-react-native && yarn build:noise-cancellation-react-native && yarn build:callingx && yarn build:react-native:sdk",
"build:vercel": "yarn build:react:deps && yarn build:react:dogfood",
"start:egress": "yarn workspace @stream-io/egress-composite start",
"build:egress": "yarn workspace @stream-io/egress-composite build",
diff --git a/packages/react-native-callingx/.editorconfig b/packages/react-native-callingx/.editorconfig
new file mode 100644
index 0000000000..65365be68e
--- /dev/null
+++ b/packages/react-native-callingx/.editorconfig
@@ -0,0 +1,15 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+indent_style = space
+indent_size = 2
+
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
diff --git a/packages/react-native-callingx/.gitattributes b/packages/react-native-callingx/.gitattributes
new file mode 100644
index 0000000000..e27f70fa49
--- /dev/null
+++ b/packages/react-native-callingx/.gitattributes
@@ -0,0 +1,3 @@
+*.pbxproj -text
+# specific for windows script files
+*.bat text eol=crlf
diff --git a/packages/react-native-callingx/.nvmrc b/packages/react-native-callingx/.nvmrc
new file mode 100644
index 0000000000..c004e356d6
--- /dev/null
+++ b/packages/react-native-callingx/.nvmrc
@@ -0,0 +1 @@
+v22.20.0
diff --git a/packages/react-native-callingx/.watchmanconfig b/packages/react-native-callingx/.watchmanconfig
new file mode 100644
index 0000000000..9e26dfeeb6
--- /dev/null
+++ b/packages/react-native-callingx/.watchmanconfig
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/packages/react-native-callingx/CODE_OF_CONDUCT.md b/packages/react-native-callingx/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000..8b4fcfd341
--- /dev/null
+++ b/packages/react-native-callingx/CODE_OF_CONDUCT.md
@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+ and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall
+ community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances of
+ any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address,
+ without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
diff --git a/packages/react-native-callingx/CONTRIBUTING.md b/packages/react-native-callingx/CONTRIBUTING.md
new file mode 100644
index 0000000000..fe8c655768
--- /dev/null
+++ b/packages/react-native-callingx/CONTRIBUTING.md
@@ -0,0 +1,129 @@
+# Contributing
+
+Contributions are always welcome, no matter how large or small!
+
+We want this community to be friendly and respectful to each other. Please follow it in all your interactions with the project. Before contributing, please read the [code of conduct](./CODE_OF_CONDUCT.md).
+
+## Development workflow
+
+This project is a monorepo managed using [Yarn workspaces](https://yarnpkg.com/features/workspaces). It contains the following packages:
+
+- The library package in the root directory.
+- An example app in the `example/` directory.
+
+To get started with the project, make sure you have the correct version of [Node.js](https://nodejs.org/) installed. See the [`.nvmrc`](./.nvmrc) file for the version used in this project.
+
+Run `yarn` in the root directory to install the required dependencies for each package:
+
+```sh
+yarn
+```
+
+> Since the project relies on Yarn workspaces, you cannot use [`npm`](https://github.com/npm/cli) for development without manually migrating.
+
+The [example app](/example/) demonstrates usage of the library. You need to run it to test any changes you make.
+
+It is configured to use the local version of the library, so any changes you make to the library's source code will be reflected in the example app. Changes to the library's JavaScript code will be reflected in the example app without a rebuild, but native code changes will require a rebuild of the example app.
+
+If you want to use Android Studio or Xcode to edit the native code, you can open the `example/android` or `example/ios` directories respectively in those editors. To edit the Objective-C or Swift files, open `example/ios/CallingxExample.xcworkspace` in Xcode and find the source files at `Pods > Development Pods > react-native-callingx`.
+
+To edit the Java or Kotlin files, open `example/android` in Android studio and find the source files at `react-native-callingx` under `Android`.
+
+You can use various commands from the root directory to work with the project.
+
+To start the packager:
+
+```sh
+yarn example start
+```
+
+To run the example app on Android:
+
+```sh
+yarn example android
+```
+
+To run the example app on iOS:
+
+```sh
+yarn example ios
+```
+
+To confirm that the app is running with the new architecture, you can check the Metro logs for a message like this:
+
+```sh
+Running "CallingxExample" with {"fabric":true,"initialProps":{"concurrentRoot":true},"rootTag":1}
+```
+
+Note the `"fabric":true` and `"concurrentRoot":true` properties.
+
+Make sure your code passes TypeScript:
+
+```sh
+yarn typecheck
+```
+
+To check for linting errors, run the following:
+
+```sh
+yarn lint
+```
+
+To fix formatting errors, run the following:
+
+```sh
+yarn lint --fix
+```
+
+Remember to add tests for your change if possible. Run the unit tests by:
+
+```sh
+yarn test
+```
+
+### Commit message convention
+
+We follow the [conventional commits specification](https://www.conventionalcommits.org/en) for our commit messages:
+
+- `fix`: bug fixes, e.g. fix crash due to deprecated method.
+- `feat`: new features, e.g. add new method to the module.
+- `refactor`: code refactor, e.g. migrate from class components to hooks.
+- `docs`: changes into documentation, e.g. add usage example for the module.
+- `test`: adding or updating tests, e.g. add integration tests using detox.
+- `chore`: tooling changes, e.g. change CI config.
+
+Our pre-commit hooks verify that your commit message matches this format when committing.
+
+### Publishing to npm
+
+We use [release-it](https://github.com/release-it/release-it) to make it easier to publish new versions. It handles common tasks like bumping version based on semver, creating tags and releases etc.
+
+To publish new versions, run the following:
+
+```sh
+yarn release
+```
+
+### Scripts
+
+The `package.json` file contains various scripts for common tasks:
+
+- `yarn`: setup project by installing dependencies.
+- `yarn typecheck`: type-check files with TypeScript.
+- `yarn lint`: lint files with [ESLint](https://eslint.org/).
+- `yarn test`: run unit tests with [Jest](https://jestjs.io/).
+- `yarn example start`: start the Metro server for the example app.
+- `yarn example android`: run the example app on Android.
+- `yarn example ios`: run the example app on iOS.
+
+### Sending a pull request
+
+> **Working on your first pull request?** You can learn how from this _free_ series: [How to Contribute to an Open Source Project on GitHub](https://app.egghead.io/playlists/how-to-contribute-to-an-open-source-project-on-github).
+
+When you're sending a pull request:
+
+- Prefer small pull requests focused on one change.
+- Verify that linters and tests are passing.
+- Review the documentation to make sure it looks good.
+- Follow the pull request template when opening a pull request.
+- For pull requests that change the API or implementation, discuss with maintainers first by opening an issue.
diff --git a/packages/react-native-callingx/Callingx.podspec b/packages/react-native-callingx/Callingx.podspec
new file mode 100644
index 0000000000..de77381a5d
--- /dev/null
+++ b/packages/react-native-callingx/Callingx.podspec
@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+ s.name = "Callingx"
+ s.version = package["version"]
+ s.summary = package["description"]
+ s.homepage = package["homepage"]
+ s.license = package["license"]
+ s.authors = package["author"]
+
+ s.platforms = { :ios => min_ios_version_supported }
+ s.source = { :git => "https://github.com/greenfrvr/react-native-callingx.git", :tag => "#{s.version}" }
+
+ s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+ # s.private_header_files = "ios/**/*.h"
+ s.public_header_files = "ios/CallingxPublic.h" #this is needed to make static methods visible
+
+ install_modules_dependencies(s)
+end
diff --git a/packages/react-native-callingx/LICENSE b/packages/react-native-callingx/LICENSE
new file mode 100644
index 0000000000..e64a3f45af
--- /dev/null
+++ b/packages/react-native-callingx/LICENSE
@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Artsiom Grintsevich
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/react-native-callingx/README.md b/packages/react-native-callingx/README.md
new file mode 100644
index 0000000000..d9bbff63e5
--- /dev/null
+++ b/packages/react-native-callingx/README.md
@@ -0,0 +1,412 @@
+# 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.
+
+## Features
+
+- 📞 **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
+
+```sh
+npm install react-native-callingx
+# or
+yarn add react-native-callingx
+```
+
+### iOS Setup
+
+1. Add the required background modes to your `Info.plist`:
+
+```xml
+UIBackgroundModes
+
+ voip
+ audio
+
+```
+
+2. Run pod install:
+
+```sh
+cd ios && pod install
+```
+
+3. For VoIP push notifications, configure your `AppDelegate` to report incoming calls:
+
+```objc
+#import
+
+- (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
+ fromPushKit:YES
+ payload:payload.dictionaryPayload
+ withCompletionHandler:completion];
+}
+```
+
+### Android Setup
+
+Handle incoming call intents in your `MainActivity`:
+
+```kotlin
+import android.content.Intent
+import android.os.Bundle
+import com.callingx.CallingxModule
+
+class MainActivity : ReactActivity() {
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ CallingxModule.handleCallingIntent(this, intent)
+ }
+
+ override fun onNewIntent(intent: Intent) {
+ super.onNewIntent(intent)
+ CallingxModule.handleCallingIntent(this, intent)
+ }
+}
+```
+
+## Usage
+
+### 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'
+ },
+ android: {
+ incomingChannel: {
+ id: 'incoming_calls',
+ name: 'Incoming Calls',
+ sound: 'ringtone', // optional custom sound
+ vibration: true,
+ },
+ 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',
+ 'John Doe',
+ false // audio only
+);
+```
+
+### 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'
+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 local user
+ | 'remote' // Call ended by remote party
+ | 'rejected' // Call was rejected
+ | 'busy' // Remote party is busy
+ | 'answeredElsewhere' // Answered on another device
+ | 'missed' // Call was missed
+ | 'error'; // Call failed due to error
+
+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
+
+### 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
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
diff --git a/packages/react-native-callingx/android/build.gradle b/packages/react-native-callingx/android/build.gradle
new file mode 100644
index 0000000000..dd344a9b40
--- /dev/null
+++ b/packages/react-native-callingx/android/build.gradle
@@ -0,0 +1,81 @@
+buildscript {
+ ext.getExtOrDefault = {name ->
+ return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Callingx_' + name]
+ }
+
+ repositories {
+ google()
+ mavenCentral()
+ }
+
+ dependencies {
+ classpath "com.android.tools.build:gradle:8.7.2"
+ // noinspection DifferentKotlinGradleVersion
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+ }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "kotlin-parcelize"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+ return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Callingx_" + name]).toInteger()
+}
+
+android {
+ namespace "com.callingx"
+
+ compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+ defaultConfig {
+ minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+ targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+ }
+
+ buildFeatures {
+ buildConfig true
+ }
+
+ buildTypes {
+ release {
+ minifyEnabled false
+ }
+ }
+
+ lintOptions {
+ disable "GradleCompatible"
+ }
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+
+ sourceSets {
+ main {
+ java.srcDirs += [
+ "generated/java",
+ "generated/jni",
+ "build/generated/source/codegen/java",
+ "build/generated/source/codegen/jni"
+ ]
+ }
+ }
+}
+
+repositories {
+ mavenCentral()
+ google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+ implementation "com.facebook.react:react-android"
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation "androidx.core:core-telecom:1.0.1"
+}
diff --git a/packages/react-native-callingx/android/gradle.properties b/packages/react-native-callingx/android/gradle.properties
new file mode 100644
index 0000000000..6567d6ce3d
--- /dev/null
+++ b/packages/react-native-callingx/android/gradle.properties
@@ -0,0 +1,5 @@
+Callingx_kotlinVersion=2.0.21
+Callingx_minSdkVersion=24
+Callingx_targetSdkVersion=34
+Callingx_compileSdkVersion=35
+Callingx_ndkVersion=27.1.12297006
diff --git a/packages/react-native-callingx/android/src/main/AndroidManifest.xml b/packages/react-native-callingx/android/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..dae1911c08
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/AndroidManifest.xml
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/CallService.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/CallService.kt
new file mode 100644
index 0000000000..caf82c1ac3
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/CallService.kt
@@ -0,0 +1,364 @@
+package com.callingx
+
+import CallRepository
+import android.app.Service
+import android.content.Intent
+import android.net.Uri
+import android.os.Binder
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import android.telecom.DisconnectCause
+import android.util.Log
+import com.callingx.model.Call
+import com.callingx.model.CallAction
+import com.callingx.notifications.CallNotificationManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+/**
+ * This service handles the app call logic (show notification, record mic, display audio, etc..). It
+ * can get started by the user or by an upcoming push notification to start a call.
+ *
+ * It holds the call scope used to register a call with the Telecom SDK in our
+ * TelecomCallRepository.
+ *
+ * When registering a call with the Telecom SDK and displaying a CallStyle notification, the SDK
+ * will grant you foreground service delegation so there is no need to make this a FGS.
+ *
+ * Note: you could potentially make this service run in a different process since audio or video
+ * calls can consume significant memory, although that would require more complex setup to make it
+ * work across multiple process.
+ */
+class CallService : Service(), CallRepository.Listener {
+
+ companion object {
+ private const val TAG = "[Callingx] CallService"
+
+ internal const val EXTRA_CALL_ID = "extra_call_id"
+ internal const val EXTRA_NAME = "extra_name"
+ internal const val EXTRA_URI = "extra_uri"
+ internal const val EXTRA_IS_VIDEO = "extra_is_video"
+ internal const val EXTRA_DISPLAY_TITLE = "displayTitle"
+ internal const val EXTRA_DISPLAY_SUBTITLE = "displaySubtitle"
+ internal const val EXTRA_DISPLAY_OPTIONS = "display_options"
+ // Background task extras
+ internal const val EXTRA_TASK_NAME = "task_name"
+ internal const val EXTRA_TASK_DATA = "task_data"
+ internal const val EXTRA_TASK_TIMEOUT = "task_timeout"
+
+ internal const val ACTION_INCOMING_CALL = "incoming_call"
+ internal const val ACTION_OUTGOING_CALL = "outgoing_call"
+ internal const val ACTION_UPDATE_CALL = "update_call"
+ internal const val ACTION_START_BACKGROUND_TASK = "start_background_task"
+ internal const val ACTION_STOP_BACKGROUND_TASK = "stop_background_task"
+ internal const val ACTION_STOP_SERVICE = "stop_service"
+ }
+
+ inner class CallServiceBinder : Binder() {
+ fun getService(): CallService = this@CallService
+ }
+
+ private lateinit var headlessJSManager: HeadlessTaskManager
+ private lateinit var notificationManager: CallNotificationManager
+ private lateinit var callRepository: CallRepository
+
+ private val binder = CallServiceBinder()
+ private val scope: CoroutineScope = CoroutineScope(SupervisorJob())
+
+ private var isInForeground = false
+
+ override fun onCreate() {
+ super.onCreate()
+ Log.d(TAG, "[service] onCreate: TelecomCallService created")
+
+ notificationManager = CallNotificationManager(applicationContext)
+ headlessJSManager = HeadlessTaskManager(applicationContext)
+ callRepository = CallRepositoryFactory.create(applicationContext)
+ callRepository.setListener(this)
+
+ sendBroadcastEvent(CallingxModule.SERVICE_READY_ACTION)
+ }
+
+ override fun onDestroy() {
+ super.onDestroy()
+ Log.d(TAG, "[service] onDestroy: TelecomCallService destroyed")
+
+ notificationManager.cancelNotifications()
+ notificationManager.stopRingtone()
+ callRepository.release()
+ headlessJSManager.release()
+
+ if (isInForeground) {
+ stopForeground(STOP_FOREGROUND_REMOVE)
+ isInForeground = false
+ }
+
+ scope.cancel()
+ }
+
+ override fun onTaskRemoved(rootIntent: Intent?) {
+ super.onTaskRemoved(rootIntent)
+ Log.d(TAG, "[service] onTaskRemoved: Task removed")
+ }
+
+ override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+ Log.d(TAG, "[service] onStartCommand: Received intent with action: ${intent?.action}")
+
+ if (intent == null || intent.action == null) {
+ Log.w(TAG, "[service] onStartCommand: Intent is null, returning START_NOT_STICKY")
+ return START_NOT_STICKY
+ }
+
+ when (intent.action) {
+ ACTION_INCOMING_CALL -> {
+ registerCall(intent, true)
+ }
+ ACTION_OUTGOING_CALL -> {
+ registerCall(intent, false)
+ }
+ ACTION_START_BACKGROUND_TASK -> {
+ if (!isInForeground) {
+ Log.d(TAG, "[service] onStartCommand: Starting foreground for background task")
+ // for now bg task is intended to be used after a call registered and
+ // notification is shown, so we don't need to show a separate notification for
+ // bg task
+ // startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
+ isInForeground = true
+ }
+
+ val taskName = intent.getStringExtra(EXTRA_TASK_NAME)!!
+ val taskData = intent.getBundleExtra(EXTRA_TASK_DATA)!!
+ val taskTimeout = intent.getLongExtra(EXTRA_TASK_TIMEOUT, 0)
+ startBackgroundTask(taskName, taskData, taskTimeout)
+ }
+ ACTION_STOP_BACKGROUND_TASK -> {
+ stopBackgroundTask()
+ }
+ ACTION_UPDATE_CALL -> {
+ // TODO: update the call details
+ // updateServiceState(telecomRepository.currentCall.value) // not used for now
+ }
+ else -> {
+ Log.e(TAG, "[service] onStartCommand: Unknown action: ${intent.action}")
+ throw IllegalArgumentException("Unknown action")
+ }
+ }
+
+ return START_STICKY
+ }
+
+ override fun onBind(intent: Intent): IBinder? = binder
+
+ override fun onUnbind(intent: Intent): Boolean {
+ Log.d(TAG, "[service] onUnbind: Service unbound")
+ return super.onUnbind(intent)
+ }
+
+ override fun onCallStateChanged(call: Call) {
+ Log.d(TAG, "[service] onCallStateChanged: Call state changed: ${call::class.simpleName}")
+ Log.d(TAG, "[service] updateServiceState: Updating service state for call type: ${call}")
+ when (call) {
+ is Call.Registered -> {
+ Log.d(
+ TAG,
+ "[service] updateServiceState: Call registered - Active: ${call.isActive}, OnHold: ${call.isOnHold}, Muted: ${call.isMuted}"
+ )
+
+ if (call.isIncoming()) {
+ if (!call.isActive) notificationManager.startRingtone()
+ else notificationManager.stopRingtone()
+ }
+ // Update the call state.
+ if (isInForeground) {
+ Log.d(
+ TAG,
+ "[service] updateServiceState: Updating notification for call: ${call.id}"
+ )
+ notificationManager.updateCallNotification(call)
+ } else {
+ Log.d(
+ TAG,
+ "[service] updateServiceState: Starting foreground for call: ${call.id}"
+ )
+ val notification = notificationManager.createNotification(call)
+ startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
+ isInForeground = true
+ }
+ }
+ is Call.Unregistered -> {
+ Log.d(TAG, "[service] updateServiceState: Call unregistered, stopping service")
+ notificationManager.updateCallNotification(call)
+
+ if (isInForeground) {
+ stopForeground(STOP_FOREGROUND_REMOVE)
+ isInForeground = false
+ }
+
+ notificationManager.stopRingtone()
+ stopSelf()
+ }
+ is Call.None -> {
+ Log.d(TAG, "[service] updateServiceState: No active call, stopping audio loop")
+ notificationManager.updateCallNotification(call)
+
+ if (isInForeground) {
+ stopForeground(STOP_FOREGROUND_REMOVE)
+ isInForeground = false
+ }
+ notificationManager.stopRingtone()
+ }
+ }
+ }
+
+ override fun onIsCallAnswered(callId: String, source: CallRepository.EventSource) {
+ sendBroadcastEvent(CallingxModule.CALL_ANSWERED_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_SOURCE, source.name.lowercase())
+ }
+ }
+
+ override fun onIsCallDisconnected(
+ callId: String?,
+ cause: DisconnectCause,
+ source: CallRepository.EventSource
+ ) {
+ // we're not passing the callId here to prevent infinite loops
+ // callEnd event with callId will sent only when after interaction with notification buttons
+ sendBroadcastEvent(CallingxModule.CALL_END_ACTION) {
+ if (callId != null) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ }
+ putExtra(CallingxModule.EXTRA_DISCONNECT_CAUSE, getDisconnectCauseString(cause))
+ putExtra(CallingxModule.EXTRA_SOURCE, source.name.lowercase())
+ }
+ }
+
+ override fun onIsCallInactive(callId: String) {
+ sendBroadcastEvent(CallingxModule.CALL_INACTIVE_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ }
+ }
+
+ override fun onIsCallActive(callId: String) {
+ sendBroadcastEvent(CallingxModule.CALL_ACTIVE_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ }
+ }
+
+ override fun onCallRegistered(callId: String) {
+ Log.d(TAG, "[service] onCallRegistered: Call registered: $callId")
+ sendBroadcastEvent(CallingxModule.CALL_REGISTERED_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ }
+ }
+
+ override fun onMuteCallChanged(callId: String, isMuted: Boolean) {
+ Log.d(TAG, "[service] onMuteCallChanged: Call muted: $callId, $isMuted")
+ sendBroadcastEvent(CallingxModule.CALL_MUTED_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_MUTED, isMuted)
+ }
+ }
+
+ override fun onCallEndpointChanged(callId: String, endpoint: String) {
+ Log.d(TAG, "[service] onCallEndpointChanged: Call endpoint changed: $callId, $endpoint")
+ sendBroadcastEvent(CallingxModule.CALL_ENDPOINT_CHANGED_ACTION) {
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_AUDIO_ENDPOINT, endpoint)
+ }
+ }
+
+ public fun isCallRegistered(callId: String): Boolean {
+ val currentCall = callRepository.currentCall.value
+ return currentCall is Call.Registered && currentCall.id == callId
+ }
+
+ public fun hasRegisteredCall(): Boolean {
+ val currentCall = callRepository.currentCall.value
+ return currentCall is Call.Registered
+ }
+
+ public fun processAction(action: CallAction) {
+ Log.d(TAG, "[service] processAction: Processing action: ${action::class.simpleName}")
+ val currentCall = callRepository.currentCall.value
+ if (currentCall is Call.Registered) {
+ currentCall.processAction(action)
+ } else {
+ Log.e(TAG, "[service] processAction: Call not registered, ignoring action")
+ }
+ }
+
+ public fun startBackgroundTask(taskName: String, data: Bundle, timeout: Long) {
+ Log.d(
+ TAG,
+ "[service] startBackgroundTask: Starting background task: $taskName, $data, $timeout"
+ )
+ headlessJSManager.startHeadlessTask(taskName, data, timeout)
+ }
+
+ public fun stopBackgroundTask() {
+ Log.d(TAG, "[service] stopBackgroundTask: Stopping background task")
+ headlessJSManager.stopHeadlessTask()
+ }
+
+ private fun registerCall(intent: Intent, incoming: Boolean) {
+ Log.d(TAG, "[service] registerCall: ${if (incoming) "in" else "out"} call")
+
+ // If we have an ongoing call ignore command
+ if (callRepository.currentCall.value is Call.Registered) {
+ Log.w(TAG, "[service] registerCall: Call already registered, ignoring new call request")
+ return
+ }
+
+ val callId = intent.getStringExtra(EXTRA_CALL_ID)!!
+ val name = intent.getStringExtra(EXTRA_NAME)!!
+ val isVideo = intent.getBooleanExtra(EXTRA_IS_VIDEO, false)
+ val uri =
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ intent.getParcelableExtra(EXTRA_URI, Uri::class.java)!!
+ } else {
+ @Suppress("DEPRECATION") intent.getParcelableExtra(EXTRA_URI)!!
+ }
+ val displayOptions = intent.getBundleExtra(EXTRA_DISPLAY_OPTIONS)
+
+ Log.d(TAG, "[service] registerCall: Call details - Name: $name, URI: $uri")
+
+ scope.launch {
+ try {
+ callRepository.registerCall(
+ callId,
+ name,
+ uri,
+ incoming,
+ isVideo,
+ displayOptions,
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "[service] registerCall: Error registering call: ${e.message}")
+ }
+ }
+ }
+
+ private fun sendBroadcastEvent(action: String, applyParams: Intent.() -> Unit = {}) {
+ val intent =
+ Intent(action).apply {
+ setPackage(packageName)
+ applyParams(this)
+ }
+ Log.d(TAG, "[service] sendBroadcastEvent: Sending broadcast event: ${intent.action}")
+ sendBroadcast(intent)
+ }
+
+ // private fun hasMicPermission(): Boolean {
+ // val hasPermission =
+ // PermissionChecker.checkSelfPermission(
+ // this,
+ // Manifest.permission.RECORD_AUDIO,
+ // ) == PermissionChecker.PERMISSION_GRANTED
+ // Log.d(TAG, "[service] hasMicPermission: Mic permission granted = $hasPermission")
+ // return hasPermission
+ // }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxModule.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxModule.kt
new file mode 100644
index 0000000000..cff64b2d61
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxModule.kt
@@ -0,0 +1,592 @@
+package com.callingx
+
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.ServiceConnection
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import android.telecom.DisconnectCause
+import android.util.Log
+import androidx.core.content.ContextCompat
+import androidx.core.net.toUri
+import com.callingx.model.CallAction
+import com.callingx.notifications.NotificationChannelsManager
+import com.callingx.notifications.NotificationsConfig
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+@ReactModule(name = CallingxModule.NAME)
+class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec(reactContext) {
+
+ companion object {
+ const val TAG = "[Callingx] CallingxModule"
+ const val NAME = "Callingx"
+
+ const val EXTRA_CALL_ID = "call_id"
+ const val EXTRA_MUTED = "is_muted"
+ const val EXTRA_ON_HOLD = "hold"
+ const val EXTRA_DISCONNECT_CAUSE = "disconnect_cause"
+ const val EXTRA_AUDIO_ENDPOINT = "audio_endpoint"
+ const val EXTRA_SOURCE = "source"
+
+ const val CALL_REGISTERED_ACTION = "call_registered"
+ const val CALL_ANSWERED_ACTION = "call_answered"
+ // const val CALL_DISCONNECTED_ACTION = "call_disconnected"
+ const val CALL_INACTIVE_ACTION = "call_inactive"
+ const val CALL_ACTIVE_ACTION = "call_active"
+ const val CALL_MUTED_ACTION = "call_muted"
+ const val CALL_ENDPOINT_CHANGED_ACTION = "call_endpoint_changed"
+ const val CALL_END_ACTION = "call_end"
+
+ const val SERVICE_READY_ACTION = "service_ready"
+ }
+
+ private enum class BindingState {
+ UNBOUND,
+ BINDING,
+ BOUND
+ }
+
+ private var callService: CallService? = null
+ private var bindingState = BindingState.UNBOUND
+
+ private var delayedEvents = WritableNativeArray()
+ private var isModuleInitialized = false
+
+ private val notificationChannelsManager = NotificationChannelsManager(reactApplicationContext)
+ private val callEventBroadcastReceiver = CallEventBroadcastReceiver()
+ private val appStateListener =
+ object : LifecycleEventListener {
+ override fun onHostResume() {}
+
+ override fun onHostPause() {}
+
+ override fun onHostDestroy() {
+ // App destroyed - force unbind
+ Log.d(TAG, "[module] onHostDestroy: App destroyed")
+ unbindServiceSafely()
+ }
+ }
+
+ init {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ reactContext.registerReceiver(
+ callEventBroadcastReceiver,
+ getReceiverFilter(),
+ Context.RECEIVER_NOT_EXPORTED
+ )
+ } else {
+ @Suppress("UnspecifiedRegisterReceiverFlag")
+ reactContext.registerReceiver(callEventBroadcastReceiver, getReceiverFilter())
+ }
+ }
+
+ override fun getName(): String = NAME
+
+ override fun initialize() {
+ super.initialize()
+ reactApplicationContext.addLifecycleEventListener(appStateListener)
+
+ tryToBindIfNeeded()
+
+ Log.d(TAG, "[module] initialize: Initializing module")
+ }
+
+ override fun invalidate() {
+ super.invalidate()
+ Log.d(TAG, "[module] invalidate: Invalidating module")
+
+ unbindServiceSafely()
+
+ reactApplicationContext.removeLifecycleEventListener(appStateListener)
+ reactApplicationContext.unregisterReceiver(callEventBroadcastReceiver)
+ isModuleInitialized = false
+ }
+
+ override fun setupiOS(options: ReadableMap) {
+ // leave empty
+ }
+
+ override fun setupAndroid(options: ReadableMap) {
+ Log.d(TAG, "[module] setupAndroid: Setting up Android: $options")
+ val notificationsConfig =
+ NotificationsConfig.saveNotificationsConfig(reactApplicationContext, options)
+ notificationChannelsManager.setNotificationsConfig(notificationsConfig)
+ notificationChannelsManager.createNotificationChannels()
+
+ isModuleInitialized = true
+ }
+
+ override fun canPostNotifications(): Boolean {
+ return notificationChannelsManager.getNotificationStatus().canPost
+ }
+
+ override fun getInitialEvents(): WritableArray {
+ // NOTE: writabel native array can be consumed only once, think of getting rid from clear
+ // event and clear eat immidiate after getting initial events
+ val events = delayedEvents
+ delayedEvents = WritableNativeArray()
+ return events
+ }
+
+ override fun clearInitialEvents(promise: Promise) {
+ delayedEvents = WritableNativeArray()
+ promise.resolve(true)
+ }
+
+ override fun setCurrentCallActive(callId: String, promise: Promise) {
+ Log.d(TAG, "[module] activateCall: Activating call: $callId")
+ executeServiceAction(CallAction.Activate, promise)
+ }
+
+ override fun displayIncomingCall(
+ callId: String,
+ phoneNumber: String,
+ callerName: String,
+ hasVideo: Boolean,
+ displayOptions: ReadableMap?,
+ promise: Promise
+ ) {
+ Log.d(
+ TAG,
+ "[module] displayIncomingCall: Displaying incoming call: $callId, $phoneNumber, $callerName, $hasVideo"
+ )
+ if (!notificationChannelsManager.getNotificationStatus().canPost) {
+ promise.reject("ERROR", "Notifications are not granted")
+ return
+ }
+
+ startCallService(
+ CallService.ACTION_INCOMING_CALL,
+ callId,
+ callerName,
+ phoneNumber,
+ hasVideo,
+ displayOptions
+ )
+ promise.resolve(true)
+ }
+
+ override fun answerIncomingCall(callId: String, promise: Promise) {
+ Log.d(TAG, "[module] answerIncomingCall: Answering call: $callId")
+ // TODO: get the call type from the call attributes
+ val isAudioCall = true // TODO: get the call type from the call attributes
+ // registeredCall.callAttributes.callType ==
+ // CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+ // currentCall?.processAction(TelecomCallAction.Answer(isAudioCall))
+ executeServiceAction(CallAction.Answer(isAudioCall), promise)
+ }
+
+ override fun startCall(
+ callId: String,
+ phoneNumber: String,
+ callerName: String,
+ hasVideo: Boolean,
+ displayOptions: ReadableMap?,
+ promise: Promise
+ ) {
+ Log.d(
+ TAG,
+ "[module] startCall: Starting outgoing call: $callId, $phoneNumber, $callerName, $hasVideo, $displayOptions"
+ )
+ if (!notificationChannelsManager.getNotificationStatus().canPost) {
+ promise.reject("ERROR", "Notifications are not granted")
+ return
+ }
+
+ startCallService(
+ CallService.ACTION_OUTGOING_CALL,
+ callId,
+ callerName,
+ phoneNumber,
+ hasVideo,
+ displayOptions
+ )
+ promise.resolve(true)
+ }
+
+ override fun updateDisplay(
+ callId: String,
+ phoneNumber: String,
+ callerName: String,
+ displayOptions: ReadableMap?,
+ promise: Promise
+ ) {
+ Log.d(TAG, "[module] updateDisplay: Updating display: $callId, $phoneNumber, $callerName")
+ if (!notificationChannelsManager.getNotificationStatus().canPost) {
+ promise.reject("ERROR", "Notifications are not granted")
+ return
+ }
+
+ startCallService(
+ CallService.ACTION_UPDATE_CALL,
+ callId,
+ callerName,
+ phoneNumber,
+ false,
+ displayOptions,
+ )
+ promise.resolve(true)
+ }
+
+ override fun endCallWithReason(callId: String, reason: Double, promise: Promise) {
+ Log.d(TAG, "[module] endCallWithReason: Ending call: $callId, $reason")
+ val action = CallAction.Disconnect(DisconnectCause(reason.toInt()))
+ executeServiceAction(action, promise)
+ }
+
+ override fun endCall(callId: String, promise: Promise) {
+ Log.d(TAG, "[module] endCall: Ending call: $callId")
+ val action = CallAction.Disconnect(DisconnectCause(DisconnectCause.LOCAL))
+ executeServiceAction(action, promise)
+ }
+
+ override fun isCallRegistered(callId: String): Boolean {
+ val isCallRegistered = callService?.isCallRegistered(callId) ?: false
+ Log.d(TAG, "[module] isCallRegistered: Is call registered: $isCallRegistered")
+ return isCallRegistered
+ }
+
+ override fun hasRegisteredCall(): Boolean {
+ val hasRegisteredCall = callService?.hasRegisteredCall() ?: false
+ Log.d(TAG, "[module] hasRegisteredCall: Has registered call: $hasRegisteredCall")
+ return hasRegisteredCall
+ }
+
+ override fun setMutedCall(callId: String, isMuted: Boolean, promise: Promise) {
+ Log.d(TAG, "[module] setMutedCall: Setting muted call: $callId, $isMuted")
+ val action = CallAction.ToggleMute(isMuted)
+ executeServiceAction(action, promise)
+ }
+
+ override fun setOnHoldCall(callId: String, isOnHold: Boolean, promise: Promise) {
+ Log.d(TAG, "[module] setOnHoldCall: Setting on hold call: $callId, $isOnHold")
+ val action = if (isOnHold) CallAction.Hold else CallAction.Activate
+ executeServiceAction(action, promise)
+ }
+
+ override fun startBackgroundTask(taskName: String, timeout: Double, promise: Promise) {
+ Log.d(TAG, "[module] startBackgroundTask: Starting background task: $taskName, $timeout")
+
+ Intent(reactApplicationContext, CallService::class.java)
+ .apply {
+ this.action = CallService.ACTION_START_BACKGROUND_TASK
+ putExtra(CallService.EXTRA_TASK_NAME, taskName)
+ putExtra(CallService.EXTRA_TASK_DATA, Bundle())
+ putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
+ }
+ .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+
+ promise.resolve(true)
+ }
+
+ override fun stopBackgroundTask(taskName: String, promise: Promise) {
+ Log.d(TAG, "[module] stopBackgroundTask: Stopping background task: $taskName")
+
+ Intent(reactApplicationContext, CallService::class.java)
+ .apply {
+ this.action = CallService.ACTION_STOP_BACKGROUND_TASK
+ putExtra(CallService.EXTRA_TASK_NAME, taskName)
+ }
+ .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+
+ promise.resolve(true)
+ }
+
+ override fun log(message: String, level: String) {
+ Log.d(TAG, "[module] log: $message, $level")
+ when (level) {
+ "debug" -> Log.d(TAG, "[module] log: $message")
+ "info" -> Log.i(TAG, "[module] log: $message")
+ "warn" -> Log.w(TAG, "[module] log: $message")
+ "error" -> Log.e(TAG, "[module] log: $message")
+ }
+ }
+
+ private fun startCallService(
+ action: String,
+ callId: String,
+ callerName: String,
+ phoneNumber: String,
+ hasVideo: Boolean,
+ displayOptions: ReadableMap?
+ ) {
+ Intent(reactApplicationContext, CallService::class.java)
+ .apply {
+ this.action = action
+ putExtra(CallService.EXTRA_CALL_ID, callId)
+ putExtra(CallService.EXTRA_NAME, callerName)
+ putExtra(CallService.EXTRA_URI, phoneNumber.toUri())
+ putExtra(CallService.EXTRA_IS_VIDEO, hasVideo)
+ putExtra(CallService.EXTRA_DISPLAY_OPTIONS, Arguments.toBundle(displayOptions))
+ }
+ .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+ }
+
+ private fun executeServiceAction(action: CallAction, promise: Promise) {
+ Log.d(TAG, "[module] executeServiceAction: Executing service action: $action")
+ when (bindingState) {
+ BindingState.BOUND -> {
+ if (callService != null) {
+ callService?.processAction(action)
+ promise.resolve(true)
+ } else {
+ promise.reject("ERROR", "Service reference lost")
+ }
+ }
+ BindingState.BINDING -> {
+ Log.d(TAG, "executeServiceAction: Service binding, queueing action")
+ promise.reject(
+ "SERVICE_BINDING",
+ "Service is connecting, please try again in a moment"
+ )
+ }
+ BindingState.UNBOUND -> {
+ promise.reject(
+ "SERVICE_NOT_CONNECTED",
+ "Service not connected. Call may not be active."
+ )
+ }
+ }
+ }
+
+ private fun sendJSEvent(eventName: String, params: WritableMap? = null) {
+ if (isModuleInitialized && reactApplicationContext.hasActiveReactInstance()) {
+ val paramsMap =
+ Arguments.createMap().apply {
+ params?.let {
+ it.toHashMap().forEach { key, value ->
+ if (value is Boolean) {
+ putBoolean(key, value)
+ } else {
+ putString(key, value.toString())
+ }
+ }
+ }
+ }
+ reactApplicationContext
+ .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+ .emit(eventName, params)
+
+ val value =
+ Arguments.createMap().apply {
+ putString("eventName", eventName)
+ putMap("params", paramsMap)
+ }
+ emitOnNewEvent(value)
+ } else {
+ Arguments.createMap()
+ .apply {
+ putString("name", eventName)
+ putMap("params", params)
+ }
+ .also { delayedEvents.pushMap(it) }
+ }
+ }
+
+ private fun getReceiverFilter(): IntentFilter =
+ IntentFilter().apply {
+ addAction(CALL_REGISTERED_ACTION)
+ addAction(CALL_ANSWERED_ACTION)
+ addAction(CALL_ACTIVE_ACTION)
+ addAction(CALL_INACTIVE_ACTION)
+ addAction(CALL_MUTED_ACTION)
+ addAction(CALL_ENDPOINT_CHANGED_ACTION)
+ addAction(CALL_END_ACTION)
+ addAction(SERVICE_READY_ACTION)
+ }
+
+ private fun bindToServiceIfNeeded() {
+ when (bindingState) {
+ BindingState.BOUND -> {
+ Log.d(TAG, "[module] bindToServiceIfNeeded: Already bound")
+ return
+ }
+ BindingState.BINDING -> {
+ Log.d(TAG, "[module] bindToServiceIfNeeded: Already binding")
+ return
+ }
+ BindingState.UNBOUND -> {
+ Log.d(TAG, "[module] bindToServiceIfNeeded: Attempting to bind")
+ val intent = Intent(reactApplicationContext, CallService::class.java)
+ try {
+ val success =
+ reactApplicationContext.bindService(
+ intent,
+ serviceConnection,
+ Context.BIND_AUTO_CREATE or Context.BIND_IMPORTANT
+ )
+ if (success) {
+ bindingState = BindingState.BINDING
+ Log.d(TAG, "[module] bindToServiceIfNeeded: Bind request successful")
+ } else {
+ Log.e(TAG, "[module] bindToServiceIfNeeded: Bind request failed")
+ bindingState = BindingState.UNBOUND
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "[module] bindToServiceIfNeeded: Exception during bind", e)
+ bindingState = BindingState.UNBOUND
+ }
+ }
+ }
+ }
+
+ private fun unbindServiceSafely() {
+ Log.d(TAG, "[module] unbindServiceSafely: Unbinding service")
+ if (bindingState == BindingState.BOUND || bindingState == BindingState.BINDING) {
+ try {
+ reactApplicationContext.unbindService(serviceConnection)
+ Log.d(TAG, "[module] unbindServiceSafely: Successfully unbound")
+ } catch (e: IllegalArgumentException) {
+ Log.w(
+ TAG,
+ "[module] unbindServiceSafely: Service not registered or already unbound"
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "[module] unbindServiceSafely: Error unbinding service", e)
+ } finally {
+ bindingState = BindingState.UNBOUND
+ callService = null
+ }
+ }
+ }
+
+ private fun tryToBindIfNeeded() {
+ val intent = Intent(reactApplicationContext, CallService::class.java)
+ try {
+ val success =
+ reactApplicationContext.bindService(
+ intent,
+ serviceConnection,
+ 0 // No flags - only bind if service exists
+ )
+ if (success) {
+ bindingState = BindingState.BINDING
+ Log.d(TAG, "[module] checkForExistingService: Service exists, binding")
+ } else {
+ Log.d(TAG, "[module] checkForExistingService: No existing service")
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "[module] checkForExistingService: Error checking for service", e)
+ }
+ }
+
+ private inner class CallEventBroadcastReceiver : BroadcastReceiver() {
+ override fun onReceive(context: Context, intent: Intent) {
+ val action = intent.action
+ val callId = intent.getStringExtra(EXTRA_CALL_ID)
+
+ Log.d(
+ TAG,
+ "[module] onReceive: Received intent: $action callId: $callId callService: ${callService != null}"
+ )
+
+ if (action == SERVICE_READY_ACTION) {
+ Log.d(TAG, "[module] onReceive: Service is ready, initiating binding")
+ bindToServiceIfNeeded()
+ return
+ }
+
+ if (action == null) {
+ Log.e(TAG, "[module] onReceive: Received intent with null action or callId")
+ return
+ }
+
+ val params = Arguments.createMap()
+ if (callId != null) {
+ params.putString("callId", callId)
+ }
+
+ when (action) {
+ CALL_REGISTERED_ACTION -> {
+ sendJSEvent("didReceiveStartCallAction", params)
+ }
+ CALL_ANSWERED_ACTION -> {
+ if (intent.hasExtra(EXTRA_SOURCE)) {
+ params.putString("source", intent.getStringExtra(EXTRA_SOURCE))
+ }
+ sendJSEvent("answerCall", params)
+ }
+ CALL_END_ACTION -> {
+ if (callId == null) {
+ // means the call was disconnected, we're ready to unbind the service
+ unbindServiceSafely()
+ }
+
+ params.putString("cause", intent.getStringExtra(EXTRA_DISCONNECT_CAUSE))
+ if (intent.hasExtra(EXTRA_SOURCE)) {
+ params.putString("source", intent.getStringExtra(EXTRA_SOURCE))
+ }
+ sendJSEvent("endCall", params)
+ }
+ CALL_INACTIVE_ACTION -> {
+ params.putBoolean("hold", true)
+ sendJSEvent("didToggleHoldCallAction", params)
+ }
+ CALL_ACTIVE_ACTION -> {
+ params.putBoolean("hold", false)
+ sendJSEvent("didToggleHoldCallAction", params)
+ }
+ CALL_MUTED_ACTION -> {
+ if (intent.hasExtra(EXTRA_MUTED)) {
+ params.putBoolean("muted", intent.getBooleanExtra(EXTRA_MUTED, false))
+ }
+ sendJSEvent("didPerformSetMutedCallAction", params)
+ }
+ CALL_ENDPOINT_CHANGED_ACTION -> {
+ if (intent.hasExtra(EXTRA_AUDIO_ENDPOINT)) {
+ params.putString("output", intent.getStringExtra(EXTRA_AUDIO_ENDPOINT))
+ }
+ sendJSEvent("didChangeAudioRoute", params)
+ }
+ }
+ }
+ }
+
+ private val serviceConnection =
+ object : ServiceConnection {
+ override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+ Log.d(TAG, "[module] onServiceConnected: Service connected")
+ val binder = service as? CallService.CallServiceBinder
+ callService = binder?.getService()
+ bindingState = BindingState.BOUND
+ }
+
+ override fun onServiceDisconnected(name: ComponentName?) {
+ Log.d(TAG, "onServiceDisconnected: Service disconnected unexpectedly")
+ callService = null
+ bindingState = BindingState.UNBOUND
+ }
+
+ override fun onBindingDied(name: ComponentName?) {
+ Log.e(TAG, "[module] onBindingDied: Service binding died")
+ callService = null
+ bindingState = BindingState.UNBOUND
+
+ // Must unbind to clean up the dead binding
+ try {
+ reactApplicationContext.unbindService(this)
+ } catch (e: Exception) {
+ Log.w(TAG, "[module] onBindingDied: Error unbinding dead connection", e)
+ }
+ }
+
+ override fun onNullBinding(name: ComponentName?) {
+ Log.e(TAG, "[module] onNullBinding: Service returned null binding")
+ bindingState = BindingState.UNBOUND
+ callService = null
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxPackage.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxPackage.kt
new file mode 100644
index 0000000000..f7ca68c6b7
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/CallingxPackage.kt
@@ -0,0 +1,16 @@
+package com.callingx
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class CallingPackage : BaseReactPackage() {
+ override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+ if (name == CallingxModule.NAME) CallingxModule(reactContext) else null
+
+ override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+ mapOf(CallingxModule.NAME to ReactModuleInfo(CallingxModule.NAME, CallingxModule.NAME, false, false, false, true))
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/HeadlessTaskManager.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/HeadlessTaskManager.kt
new file mode 100644
index 0000000000..a3ecb1c4d4
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/HeadlessTaskManager.kt
@@ -0,0 +1,165 @@
+package com.callingx
+
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+
+class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventListener {
+
+ private var activeTaskId: Int? = null
+
+ companion object {
+ private const val TAG = "TelecomHeadlessJSHelper"
+ }
+
+ public fun startHeadlessTask(taskName: String, data: Bundle, timeout: Long) {
+ if (activeTaskId != null) {
+ Log.w(TAG, "startHeadlessTask: Task already starting or active, ignoring new task request")
+ return
+ }
+
+ if (UiThreadUtil.isOnUiThread()) {
+ startTask(HeadlessJsTaskConfig(taskName, Arguments.fromBundle(data), timeout, true))
+ } else {
+ UiThreadUtil.runOnUiThread(
+ Runnable {
+ startTask(HeadlessJsTaskConfig(taskName, Arguments.fromBundle(data), timeout, true))
+ }
+ )
+ }
+ }
+
+ public fun stopHeadlessTask() {
+ Log.d(TAG, "stopHeadlessTask: Stopping headless task")
+ activeTaskId?.let { taskId ->
+ if (UiThreadUtil.isOnUiThread()) {
+ stopTask(taskId)
+ } else {
+ UiThreadUtil.runOnUiThread(Runnable { stopTask(taskId) })
+ }
+ }
+ }
+
+ protected fun startTask(taskConfig: HeadlessJsTaskConfig) {
+ UiThreadUtil.assertOnUiThread()
+ // acquireWakeLockNow(this)
+
+ val context = reactContext
+ if (context == null) {
+ createReactContextAndScheduleTask(taskConfig)
+ } else {
+ invokeStartTask(context, taskConfig)
+ }
+ }
+
+ private fun invokeStartTask(reactContext: ReactContext, taskConfig: HeadlessJsTaskConfig) {
+ Log.d(TAG, "invokeStartTask: Invoking start task")
+ val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
+ headlessJsTaskContext.addTaskEventListener(this)
+
+ UiThreadUtil.runOnUiThread {
+ val taskId = headlessJsTaskContext.startTask(taskConfig)
+ activeTaskId = taskId
+ }
+ }
+
+ private fun stopTask(taskId: Int) {
+ reactContext?.let { context ->
+ val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
+ if (headlessJsTaskContext.isTaskRunning(taskId)) {
+ headlessJsTaskContext.finishTask(taskId)
+ Log.d(TAG, "Stopped task: $taskId")
+ }
+ }
+ }
+
+ fun release() {
+ stopHeadlessTask()
+
+ reactContext?.let { context ->
+ val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
+ headlessJsTaskContext.removeTaskEventListener(this)
+ }
+ // wakeLock?.release()
+ }
+
+ override fun onHeadlessJsTaskStart(taskId: Int) {
+ Log.d(TAG, "onHeadlessJsTaskStart: Task started: $taskId")
+ }
+
+ override fun onHeadlessJsTaskFinish(taskId: Int) {
+ Log.d(TAG, "onHeadlessJsTaskFinish: Task finished: $taskId")
+ activeTaskId = null
+ }
+
+ /**
+ * Get the [ReactNativeHost] used by this app. By default, assumes [getApplication] is an instance
+ * of [ReactApplication] and calls [ReactApplication.reactNativeHost].
+ *
+ * Override this method if your application class does not implement `ReactApplication` or you
+ * simply have a different mechanism for storing a `ReactNativeHost`, e.g. as a static field
+ * somewhere.
+ */
+ @Suppress("DEPRECATION")
+ protected open val reactNativeHost: ReactNativeHost
+ get() = (context.applicationContext as ReactApplication).reactNativeHost
+
+ /**
+ * Get the [ReactHost] used by this app. By default, assumes [getApplication] is an instance of
+ * [ReactApplication] and calls [ReactApplication.reactHost]. This method assumes it is called in
+ * new architecture and returns null if not.
+ */
+ protected open val reactHost: ReactHost?
+ get() = (context.applicationContext as ReactApplication).reactHost
+
+ protected val reactContext: ReactContext?
+ get() {
+ if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
+ val reactHost =
+ checkNotNull(reactHost) { "ReactHost is not initialized in New Architecture" }
+ return reactHost.currentReactContext
+ } else {
+ val reactInstanceManager = reactNativeHost.reactInstanceManager
+ return reactInstanceManager.currentReactContext
+ }
+ }
+
+ private fun createReactContextAndScheduleTask(taskConfig: HeadlessJsTaskConfig) {
+ if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
+ val reactHost = checkNotNull(reactHost)
+ reactHost.addReactInstanceEventListener(
+ object : ReactInstanceEventListener {
+ override fun onReactContextInitialized(context: ReactContext) {
+ Log.d(TAG, "createReactContextAndScheduleTask: React context initialized")
+ invokeStartTask(context, taskConfig)
+ reactHost.removeReactInstanceEventListener(this)
+ }
+ }
+ )
+ reactHost.start()
+ } else {
+ val reactInstanceManager = reactNativeHost.reactInstanceManager
+ reactInstanceManager.addReactInstanceEventListener(
+ object : ReactInstanceEventListener {
+ override fun onReactContextInitialized(context: ReactContext) {
+ Log.d(TAG, "createReactContextAndScheduleTask: React context initialized")
+ invokeStartTask(context, taskConfig)
+ reactInstanceManager.removeReactInstanceEventListener(this)
+ }
+ }
+ )
+ reactInstanceManager.createReactContextInBackground()
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/ResourceUtils.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/ResourceUtils.kt
new file mode 100644
index 0000000000..c0d01f7e89
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/ResourceUtils.kt
@@ -0,0 +1,60 @@
+package com.callingx
+
+import android.content.Context
+import android.media.RingtoneManager
+import android.net.Uri
+import android.util.Log
+import androidx.core.net.toUri
+
+
+object ResourceUtils {
+ private const val TAG = "[Callingx] ResourceUtils"
+
+ private val resourceIdCache = mutableMapOf()
+
+ private fun getResourceIdByName(context: Context, name: String?, type: String): Int {
+ if (name.isNullOrEmpty()) {
+ return 0
+ }
+
+ val normalizedName = name.lowercase().replace("-", "_")
+ val key = "${normalizedName}_$type"
+
+ synchronized(resourceIdCache) {
+ resourceIdCache[key]?.let {
+ return it
+ }
+
+ val packageName = context.packageName
+
+ val id = context.resources.getIdentifier(normalizedName, type, packageName)
+ resourceIdCache[key] = id
+ return id
+ }
+ }
+
+ fun getSoundUri(context: Context, sound: String?): Uri? {
+ Log.d(TAG, "getSoundUri: Getting sound URI for: $sound")
+ return when {
+ sound == null -> null
+ sound.contains("://") -> sound.toUri()
+ sound.equals("default", ignoreCase = true) -> {
+ RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
+ }
+
+ else -> {
+ // The API user is attempting to set a sound by file name, verify it exists
+ var soundResourceId = getResourceIdByName(context, sound, "raw")
+ if (soundResourceId == 0 && sound.contains(".")) {
+ soundResourceId = getResourceIdByName(context, sound.substringBeforeLast('.'), "raw")
+ }
+ if (soundResourceId == 0) {
+ null
+ } else {
+ // Use the actual sound name vs the resource ID, to obtain a stable URI, Issue #341
+ "android.resource://${context.packageName}/raw/$sound".toUri()
+ }
+ }
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/Utils.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/Utils.kt
new file mode 100644
index 0000000000..aa46143723
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/Utils.kt
@@ -0,0 +1,16 @@
+package com.callingx
+
+import android.telecom.DisconnectCause
+
+fun getDisconnectCauseString(cause: DisconnectCause): String {
+ return when (cause.code) {
+ DisconnectCause.LOCAL -> "local"
+ DisconnectCause.REMOTE -> "remote"
+ DisconnectCause.REJECTED -> "rejected"
+ DisconnectCause.BUSY -> "busy"
+ DisconnectCause.ANSWERED_ELSEWHERE -> "answeredElsewhere"
+ DisconnectCause.MISSED -> "missed"
+ DisconnectCause.ERROR -> "error"
+ else -> cause.toString()
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/model/Call.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/model/Call.kt
new file mode 100644
index 0000000000..513c6b9ea1
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/model/Call.kt
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+package com.callingx.model
+
+import android.os.ParcelUuid
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import androidx.core.telecom.CallAttributesCompat
+import androidx.core.telecom.CallEndpointCompat
+import kotlinx.coroutines.channels.Channel
+
+/**
+ * Custom representation of a call state.
+ */
+sealed class Call {
+
+ /**
+ * There is no current or past calls in the stack
+ */
+ object None : Call()
+
+ /**
+ * Represents a registered call with the telecom stack with the values provided by the
+ * Telecom SDK
+ */
+ data class Registered(
+ val id: String,
+ val callAttributes: CallAttributesCompat,
+ val displayOptions: Bundle?,
+ val isActive: Boolean,
+ val isOnHold: Boolean,
+ val isMuted: Boolean,
+ val errorCode: Int?,
+ val currentCallEndpoint: CallEndpointCompat?,
+ val availableCallEndpoints: List,
+ internal val actionSource: Channel,
+ ) : Call() {
+
+ /**
+ * @return true if it's an incoming registered call, false otherwise
+ */
+ fun isIncoming() = callAttributes.direction == CallAttributesCompat.DIRECTION_INCOMING
+
+ /**
+ * Sends an action to the call session. It will be processed if it's still registered.
+ *
+ * @return true if the action was sent, false otherwise
+ */
+ fun processAction(action: CallAction) = actionSource.trySend(action).isSuccess
+ }
+
+ /**
+ * Represent a previously registered call that was disconnected
+ */
+ data class Unregistered(
+ val id: String,
+ val callAttributes: CallAttributesCompat,
+ val disconnectCause: DisconnectCause,
+ ) : Call()
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/model/CallAction.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/model/CallAction.kt
new file mode 100644
index 0000000000..a3ffe40c84
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/model/CallAction.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+package com.callingx.model
+
+import android.os.ParcelUuid
+import android.os.Parcelable
+import android.telecom.DisconnectCause
+import kotlinx.parcelize.Parcelize
+
+/**
+ * Simple interface to represent related call actions to communicate with the registered call scope
+ * in the [TelecomCallRepository.registerCall]
+ *
+ * Note: we are using [Parcelize] to make the actions parcelable so they can be directly used in the
+ * call notification.
+ */
+sealed interface CallAction : Parcelable {
+ @Parcelize
+ data class Answer(val isAudioCall: Boolean) : CallAction
+
+ @Parcelize
+ data class Disconnect(val cause: DisconnectCause) : CallAction
+
+ @Parcelize
+ object Hold : CallAction
+
+ @Parcelize
+ object Activate : CallAction
+
+ @Parcelize
+ data class ToggleMute(val isMute: Boolean) : CallAction
+
+ @Parcelize
+ data class SwitchAudioEndpoint(val endpointId: ParcelUuid) : CallAction
+
+ @Parcelize
+ data class TransferCall(val endpointId: ParcelUuid) : CallAction
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/CallNotificationManager.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/CallNotificationManager.kt
new file mode 100644
index 0000000000..2f91e3885e
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/CallNotificationManager.kt
@@ -0,0 +1,193 @@
+package com.callingx.notifications
+
+import android.app.Notification
+import android.content.Context
+import android.media.Ringtone
+import android.media.RingtoneManager
+import android.os.Build
+import android.telecom.DisconnectCause
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.Person
+import androidx.core.graphics.drawable.IconCompat
+import com.callingx.CallService
+import com.callingx.CallingxModule
+import com.callingx.R
+import com.callingx.ResourceUtils
+import com.callingx.getDisconnectCauseString
+import com.callingx.model.Call
+
+/**
+ * Handles call status changes and updates the notification accordingly. For more guidance around
+ * notifications check https://developer.android.com/develop/ui/views/notifications
+ *
+ * @see updateCallNotification
+ */
+class CallNotificationManager(
+ private val context: Context,
+ private val notificationManager: NotificationManagerCompat =
+ NotificationManagerCompat.from(context)
+) {
+
+ internal companion object {
+ private const val TAG = "[Callingx] CallNotificationManager"
+
+ const val NOTIFICATION_ID = 200
+ }
+
+ private var notificationsConfig = NotificationsConfig.loadNotificationsConfig(context)
+
+ private var ringtone: Ringtone? = null
+
+ private var hasBecameActive = false
+
+ fun createNotification(call: Call.Registered): Notification {
+ Log.d(TAG, "[notifications] createNotification: Creating notification for call ID: ${call.id}")
+
+ val contentIntent =
+ NotificationIntentFactory.getLaunchActivityIntent(
+ context,
+ CallingxModule.CALL_ANSWERED_ACTION,
+ call.id
+ )
+ val callStyle = createCallStyle(call)
+ val channelId = getChannelId(call)
+ Log.d(TAG, "[notifications] createNotification: Channel ID: $channelId")
+
+ val builder =
+ NotificationCompat.Builder(context, channelId)
+ .setContentIntent(contentIntent)
+ .setFullScreenIntent(contentIntent, true)
+ .setStyle(callStyle)
+ .setSmallIcon(R.drawable.ic_round_call_24)
+ .setCategory(NotificationCompat.CATEGORY_CALL)
+ .setPriority(NotificationCompat.PRIORITY_MAX)
+ .setOngoing(true)
+
+ if (!hasBecameActive && call.isActive) {
+ Log.d(TAG, "[notifications] createNotification: Setting when to current time")
+ builder.setWhen(System.currentTimeMillis())
+ builder.setUsesChronometer(true)
+ builder.setShowWhen(true)
+ hasBecameActive = true
+ }
+
+ call.displayOptions?.let {
+ if (it.containsKey(CallService.EXTRA_DISPLAY_SUBTITLE)) {
+ builder.setContentText(it.getString(CallService.EXTRA_DISPLAY_SUBTITLE))
+ }
+ }
+
+ return builder.build()
+ }
+
+ fun updateCallNotification(call: Call) {
+ when (call) {
+ Call.None, is Call.Unregistered -> {
+ Log.d(TAG, "[notifications] updateCallNotification: Dismissing notification (call is None or Unregistered)")
+ notificationManager.cancel(NOTIFICATION_ID)
+ }
+ is Call.Registered -> {
+ val notification = createNotification(call)
+ notificationManager.notify(NOTIFICATION_ID, notification)
+ Log.d(TAG, "[notifications] updateCallNotification: Notification posted successfully")
+ }
+ }
+ }
+
+ fun cancelNotifications() {
+ notificationManager.cancel(NOTIFICATION_ID)
+ hasBecameActive = false
+ }
+
+ fun startRingtone() {
+ if (ringtone?.isPlaying == true) {
+ Log.d(TAG, "[notifications] startRingtone: Ringtone already playing")
+ return
+ }
+
+ val soundUri =
+ ResourceUtils.getSoundUri(context, notificationsConfig.incomingChannel.sound)
+ ?: RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+
+ ringtone = RingtoneManager.getRingtone(context, soundUri)
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ ringtone?.isLooping = true
+ }
+
+ ringtone?.play()
+ Log.d(TAG, "[notifications] startRingtone: Ringtone started")
+ }
+
+ fun stopRingtone() {
+ if (ringtone?.isPlaying == true) {
+ ringtone?.stop()
+ Log.d(TAG, "[notifications] stopRingtone: Ringtone stopped")
+ }
+ ringtone = null
+ }
+
+ private fun getChannelId(call: Call.Registered): String {
+ return if (call.isIncoming() && !call.isActive) {
+ notificationsConfig.incomingChannel.id
+ } else {
+ notificationsConfig.outgoingChannel.id
+ }
+ }
+
+ private fun createCallStyle(call: Call.Registered): NotificationCompat.CallStyle {
+ val caller = createPerson(call)
+
+ if (call.isIncoming() && !call.isActive) {
+ return NotificationCompat.CallStyle.forIncomingCall(
+ caller,
+ NotificationIntentFactory.getPendingBroadcastIntent(
+ context,
+ CallingxModule.CALL_END_ACTION,
+ call.id
+ ) {
+ putExtra(
+ CallingxModule.EXTRA_DISCONNECT_CAUSE,
+ getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
+ )
+ putExtra(CallingxModule.EXTRA_SOURCE, CallRepository.EventSource.SYS.name.lowercase())
+ },
+ NotificationIntentFactory.getPendingNotificationIntent(
+ context,
+ CallingxModule.CALL_ANSWERED_ACTION,
+ call.id,
+ CallRepository.EventSource.SYS.name.lowercase()
+ )
+ )
+ }
+
+ return NotificationCompat.CallStyle.forOngoingCall(
+ caller,
+ NotificationIntentFactory.getPendingBroadcastIntent(
+ context,
+ CallingxModule.CALL_END_ACTION,
+ call.id
+ ) {
+ putExtra(
+ CallingxModule.EXTRA_DISCONNECT_CAUSE,
+ getDisconnectCauseString(DisconnectCause(DisconnectCause.LOCAL))
+ )
+ putExtra(CallingxModule.EXTRA_SOURCE, CallRepository.EventSource.SYS.name.lowercase())
+ },
+ )
+ }
+
+ private fun createPerson(call: Call.Registered): Person {
+ val displayCallerName = call.displayOptions?.getString(CallService.EXTRA_DISPLAY_TITLE)
+ val address = call.callAttributes.address.toString()
+
+ return Person.Builder()
+ .setName(displayCallerName ?: call.callAttributes.displayName)
+ .setUri(address)
+ .setIcon(IconCompat.createWithResource(context, R.drawable.ic_user))
+ .setImportant(true)
+ .build()
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationChannelsManager.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationChannelsManager.kt
new file mode 100644
index 0000000000..6a5c558e6a
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationChannelsManager.kt
@@ -0,0 +1,113 @@
+package com.callingx.notifications
+
+import android.Manifest
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationChannelCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.PermissionChecker
+
+class NotificationChannelsManager(
+ private val context: Context,
+ private val notificationManager: NotificationManagerCompat =
+ NotificationManagerCompat.from(context)
+) {
+
+ private var notificationsConfig: NotificationsConfig.Channels? = null
+
+ companion object {
+ private const val TAG = "[Callingx] NotificationChannelsManager"
+ }
+
+ data class NotificationStatus(
+ val canPost: Boolean,
+ val hasPermissions: Boolean,
+ val areNotificationsEnabled: Boolean,
+ val isIncomingChannelEnabled: Boolean,
+ val isOutgoingChannelEnabled: Boolean,
+ )
+
+ fun setNotificationsConfig(notificationsConfig: NotificationsConfig.Channels) {
+ this.notificationsConfig = notificationsConfig
+ }
+
+ fun createNotificationChannels() {
+ notificationsConfig?.let {
+ val incomingChannel = createNotificationChannel(it.incomingChannel)
+ val ongoingChannel = createNotificationChannel(it.outgoingChannel)
+
+ notificationManager.createNotificationChannelsCompat(
+ listOf(
+ incomingChannel,
+ ongoingChannel,
+ ),
+ )
+ Log.d(TAG, "createNotificationChannels: Notification channels registered")
+ }
+ }
+
+ fun getNotificationStatus(): NotificationStatus {
+ val areNotificationsEnabled = areNotificationsEnabled()
+ val hasPermissions = hasNotificationPermissions()
+ val isIncomingChannelEnabled = isChannelEnabled(notificationsConfig?.incomingChannel?.id)
+ val isOutgoingChannelEnabled = isChannelEnabled(notificationsConfig?.outgoingChannel?.id)
+
+ val canPost =
+ areNotificationsEnabled &&
+ hasPermissions &&
+ isIncomingChannelEnabled &&
+ isOutgoingChannelEnabled
+
+ return NotificationStatus(
+ canPost,
+ hasPermissions,
+ areNotificationsEnabled,
+ isIncomingChannelEnabled,
+ isOutgoingChannelEnabled
+ )
+ }
+
+ private fun createNotificationChannel(
+ config: NotificationsConfig.ChannelParams
+ ): NotificationChannelCompat {
+ return NotificationChannelCompat.Builder(config.id, config.importance)
+ .apply {
+ setName(config.name)
+ setVibrationEnabled(config.vibration)
+ setSound(null, null)
+ }
+ .build()
+ }
+
+ private fun areNotificationsEnabled(): Boolean {
+ return notificationManager.areNotificationsEnabled()
+ }
+
+ private fun hasNotificationPermissions(): Boolean {
+ // POST_NOTIFICATIONS permission is only required on Android 13+
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+ return true
+ }
+
+ val permission =
+ PermissionChecker.checkSelfPermission(
+ context,
+ Manifest.permission.POST_NOTIFICATIONS,
+ )
+ return permission == PermissionChecker.PERMISSION_GRANTED
+ }
+
+ private fun isChannelEnabled(channelId: String?): Boolean {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+ return true
+ }
+
+ if (channelId == null) {
+ return false
+ }
+
+ val channel = notificationManager.getNotificationChannel(channelId)
+ return channel != null && channel.importance != NotificationManagerCompat.IMPORTANCE_NONE
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationIntentFactory.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationIntentFactory.kt
new file mode 100644
index 0000000000..48d06267ca
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationIntentFactory.kt
@@ -0,0 +1,105 @@
+package com.callingx.notifications
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import com.callingx.CallingxModule
+
+object NotificationIntentFactory {
+ // Stable request codes for PendingIntents
+ private const val REQUEST_CODE_LAUNCH_ACTIVITY = 1001
+ private const val REQUEST_CODE_RECEIVER_ACTIVITY = 1002
+ private const val REQUEST_CODE_SERVICE = 1003
+
+ fun getPendingNotificationIntent(
+ context: Context,
+ action: String,
+ callId: String,
+ source: String
+ ): PendingIntent {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ getReceiverActivityIntent(context, action, callId, source)
+ } else {
+ getPendingServiceIntent(context, action, callId, source)
+ }
+ }
+
+ fun getPendingServiceIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+ val intent =
+ Intent(context, NotificationReceiverService::class.java).apply {
+ this.action = action
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_SOURCE, source)
+ }
+
+ return PendingIntent.getService(
+ context,
+ REQUEST_CODE_SERVICE,
+ intent,
+ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+ )
+ }
+
+ fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+ val receiverIntent =
+ Intent(context, NotificationReceiverActivity::class.java).apply {
+ this.action = action
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_SOURCE, source)
+ }
+
+ val launchActivity = context.packageManager.getLaunchIntentForPackage(context.packageName)
+ val launchActivityIntent =
+ Intent(launchActivity).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ }
+
+ return PendingIntent.getActivities(
+ context,
+ REQUEST_CODE_RECEIVER_ACTIVITY,
+ arrayOf(launchActivityIntent, receiverIntent),
+ PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+ )
+ }
+
+ fun getLaunchActivityIntent(context: Context, action: String, callId: String, source: String? = null): PendingIntent {
+ val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+ val callIntent =
+ Intent(launchIntent).apply {
+ this.action = action
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ source?.let { putExtra(CallingxModule.EXTRA_SOURCE, it) }
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ }
+
+ return PendingIntent.getActivity(
+ context,
+ REQUEST_CODE_LAUNCH_ACTIVITY,
+ callIntent,
+ PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+ )
+ }
+
+ fun getPendingBroadcastIntent(
+ context: Context,
+ action: String,
+ callId: String,
+ addExtras: Intent.() -> Unit = {}
+ ): PendingIntent {
+ val intent =
+ Intent(action).apply {
+ setPackage(context.packageName)
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ addExtras(this)
+ }
+
+ // Use action hashCode for unique request code per action type
+ return PendingIntent.getBroadcast(
+ context,
+ action.hashCode(),
+ intent,
+ PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+ )
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverActivity.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverActivity.kt
new file mode 100644
index 0000000000..1d66ce08af
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverActivity.kt
@@ -0,0 +1,42 @@
+package com.callingx.notifications
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import com.callingx.CallingxModule
+
+// For Android 12+
+class NotificationReceiverActivity : Activity() {
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ handleIntent(intent)
+ finish()
+ }
+
+ override fun onNewIntent(intent: Intent?) {
+ super.onNewIntent(intent)
+ handleIntent(intent)
+ finish()
+ }
+
+ //re-send intent from notification to the turbo module
+ private fun handleIntent(intent: Intent?) {
+ if (intent == null) {
+ return
+ }
+
+ //we need it only for answered call event, as for cold start case we need to send broadcast event and to launch the app
+ if (intent.action == CallingxModule.CALL_ANSWERED_ACTION) {
+ val callId = intent.getStringExtra(CallingxModule.EXTRA_CALL_ID)
+ val source = intent.getStringExtra(CallingxModule.EXTRA_SOURCE)
+ Intent(CallingxModule.CALL_ANSWERED_ACTION)
+ .apply {
+ setPackage(packageName)
+ putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+ putExtra(CallingxModule.EXTRA_SOURCE, source)
+ }
+ .also { sendBroadcast(it) }
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverService.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverService.kt
new file mode 100644
index 0000000000..13afa95974
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationReceiverService.kt
@@ -0,0 +1,47 @@
+package com.callingx.notifications
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import com.callingx.CallingxModule
+
+class NotificationReceiverService : Service() {
+
+ override fun onBind(intent: Intent?): IBinder? = null
+
+ override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+ val action = intent?.action
+ if (action == null) {
+ stopSelf(startId)
+ return START_NOT_STICKY
+ }
+
+ when (action) {
+ CallingxModule.CALL_ANSWERED_ACTION -> onCallAnswered(intent)
+ }
+
+ stopSelf(startId)
+ return START_NOT_STICKY
+ }
+
+ private fun onCallAnswered(intent: Intent) {
+ val callId = intent.getStringExtra(CallingxModule.EXTRA_CALL_ID)
+ val source = intent.getStringExtra(CallingxModule.EXTRA_SOURCE)
+ callId?.let {
+ NotificationIntentFactory.getPendingBroadcastIntent(
+ applicationContext,
+ CallingxModule.CALL_ANSWERED_ACTION,
+ it
+ ) { putExtra(CallingxModule.EXTRA_SOURCE, source) }
+ .send()
+
+ NotificationIntentFactory.getLaunchActivityIntent(
+ applicationContext,
+ CallingxModule.CALL_ANSWERED_ACTION,
+ it,
+ source
+ )
+ .send()
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationsConfig.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationsConfig.kt
new file mode 100644
index 0000000000..700923c00c
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/notifications/NotificationsConfig.kt
@@ -0,0 +1,116 @@
+package com.callingx.notifications
+
+import android.content.Context
+import android.util.Log
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.edit
+import com.facebook.react.bridge.ReadableMap
+
+object NotificationsConfig {
+ private const val TAG = "[Callingx] NotificationsConfig"
+ private const val PREFS_NAME = "CallingxPrefs"
+ private const val PREFIX_IN = "incoming_"
+ private const val PREFIX_OUT = "outgoing_"
+ private const val KEY_ID = "id"
+ private const val KEY_NAME = "name"
+ private const val KEY_SOUND = "sound"
+ private const val KEY_VIBRATION = "vibration"
+
+ data class ChannelParams(
+ val id: String,
+ val name: String,
+ val sound: String?,
+ val vibration: Boolean,
+ val importance: Int,
+ )
+
+ data class Channels(
+ val incomingChannel: ChannelParams,
+ val outgoingChannel: ChannelParams,
+ )
+
+ fun saveNotificationsConfig(context: Context, rawConfig: ReadableMap): Channels {
+ Log.d(TAG, "saveNotificationsConfig: Saving notifications config: $rawConfig")
+ val config = extractNotificationsConfig(rawConfig)
+ val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+ prefs.edit {
+ // Incoming channel
+ putString(PREFIX_IN + KEY_ID, config.incomingChannel.id)
+ putString(PREFIX_IN + KEY_NAME, config.incomingChannel.name)
+ putString(PREFIX_IN + KEY_SOUND, config.incomingChannel.sound)
+ putBoolean(PREFIX_IN + KEY_VIBRATION, config.incomingChannel.vibration)
+
+ // Outgoing channel
+ putString(PREFIX_OUT + KEY_ID, config.outgoingChannel.id)
+ putString(PREFIX_OUT + KEY_NAME, config.outgoingChannel.name)
+ }
+
+ return config
+ }
+
+ fun loadNotificationsConfig(context: Context): Channels {
+ val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+ Log.d(
+ TAG,
+ "loadNotificationsConfig: Loading notifications config ${
+ prefs.getString(
+ PREFIX_IN + KEY_ID,
+ ""
+ )
+ }"
+ )
+ return Channels(
+ incomingChannel =
+ ChannelParams(
+ id = prefs.getString(PREFIX_IN + KEY_ID, "") ?: "",
+ name = prefs.getString(PREFIX_IN + KEY_NAME, "") ?: "",
+ sound = prefs.getString(PREFIX_IN + KEY_SOUND, "") ?: "",
+ vibration = prefs.getBoolean(PREFIX_IN + KEY_VIBRATION, false),
+ importance = NotificationManagerCompat.IMPORTANCE_MAX,
+ ),
+ outgoingChannel =
+ ChannelParams(
+ id = prefs.getString(PREFIX_OUT + KEY_ID, "") ?: "",
+ name = prefs.getString(PREFIX_OUT + KEY_NAME, "") ?: "",
+ importance = NotificationManagerCompat.IMPORTANCE_DEFAULT,
+ vibration = false,
+ sound = null,
+ )
+ )
+ }
+
+ fun extractNotificationsConfig(config: ReadableMap): Channels {
+ return Channels(
+ incomingChannel =
+ extractChannelConfig(
+ config.getMap("incomingChannel"),
+ NotificationManagerCompat.IMPORTANCE_MAX
+ ),
+ outgoingChannel =
+ extractChannelConfig(
+ config.getMap("outgoingChannel"),
+ NotificationManagerCompat.IMPORTANCE_DEFAULT
+ ),
+ )
+ }
+
+ fun extractChannelConfig(channel: ReadableMap?, importance: Int): ChannelParams {
+ if (channel == null) {
+ return ChannelParams(
+ id = "",
+ name = "",
+ sound = "",
+ vibration = false,
+ importance = importance,
+ )
+ }
+
+ return ChannelParams(
+ id = channel.getString("id") ?: "",
+ name = channel.getString("name") ?: "",
+ sound = channel.getString("sound"),
+ vibration = channel.hasKey("vibration") && channel.getBoolean("vibration") ?: false,
+ importance = importance,
+ )
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/repo/CallRepository.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/CallRepository.kt
new file mode 100644
index 0000000000..7d2c380763
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/CallRepository.kt
@@ -0,0 +1,51 @@
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import com.callingx.model.Call
+import com.callingx.repo.TelecomCallRepository
+import kotlinx.coroutines.flow.StateFlow
+
+interface CallRepository {
+
+ enum class EventSource {
+ APP, SYS
+ }
+
+ interface Listener {
+ fun onCallStateChanged(call: Call)
+ fun onIsCallAnswered(callId: String, source: EventSource)
+ fun onIsCallDisconnected(callId: String?, cause: DisconnectCause, source: EventSource)
+ fun onIsCallInactive(callId: String)
+ fun onIsCallActive(callId: String)
+ fun onCallRegistered(callId: String)
+ fun onMuteCallChanged(callId: String, isMuted: Boolean)
+ fun onCallEndpointChanged(callId: String, endpoint: String)
+ }
+
+ val currentCall: StateFlow
+
+ fun setListener(listener: Listener)
+ fun release()
+
+ suspend fun registerCall(
+ callId: String,
+ displayName: String,
+ address: Uri,
+ isIncoming: Boolean,
+ isVideo: Boolean,
+ displayOptions: Bundle?,
+ )
+}
+
+object CallRepositoryFactory {
+
+ fun create(context: Context): CallRepository {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ TelecomCallRepository(context) // Your current CallRepository renamed
+ } else {
+ LegacyCallRepository(context) // Fallback implementation
+ }
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/repo/LegacyCallRepository.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/LegacyCallRepository.kt
new file mode 100644
index 0000000000..d27a896c8b
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/LegacyCallRepository.kt
@@ -0,0 +1,163 @@
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.util.Log
+import androidx.core.telecom.CallAttributesCompat
+import com.callingx.model.Call
+import com.callingx.model.CallAction
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+class LegacyCallRepository(private val context: Context) : CallRepository {
+
+ companion object {
+ private const val TAG = "[Callingx] LegacyCallRepository"
+ }
+
+ private val _currentCall: MutableStateFlow = MutableStateFlow(Call.None)
+ override val currentCall = _currentCall.asStateFlow()
+
+ private var listener: CallRepository.Listener? = null
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+ override fun setListener(listener: CallRepository.Listener) {
+ this.listener = listener
+ // Observe call state changes
+ scope.launch { currentCall.collect { listener.onCallStateChanged(it) } }
+ }
+
+ override fun release() {
+ _currentCall.value = Call.None
+
+ listener = null
+
+ scope.cancel()
+ }
+
+ override suspend fun registerCall(
+ callId: String,
+ displayName: String,
+ address: Uri,
+ isIncoming: Boolean,
+ isVideo: Boolean,
+ displayOptions: Bundle?,
+ ) {
+
+ val attributes = createCallAttributes(displayName, address, isIncoming, isVideo)
+ val actionSource = Channel()
+
+ _currentCall.value =
+ Call.Registered(
+ id = callId,
+ isActive = false,
+ isOnHold = false,
+ callAttributes = attributes,
+ displayOptions = displayOptions,
+ isMuted = false,
+ errorCode = null,
+ currentCallEndpoint = null,
+ availableCallEndpoints = emptyList(),
+ actionSource = actionSource,
+ )
+
+ listener?.onCallRegistered(callId)
+
+ // Process actions without telecom SDK
+ scope.launch {
+ actionSource.consumeAsFlow().collect { action -> processActionLegacy(action) }
+ }
+ }
+
+ private fun processActionLegacy(action: CallAction) {
+ when (action) {
+ is CallAction.Answer -> {
+ updateCurrentCall { copy(isActive = true, isOnHold = false) }
+ // In legacy mode, all actions are initiated from the app
+ (currentCall.value as? Call.Registered)?.let {
+ listener?.onIsCallAnswered(it.id, CallRepository.EventSource.APP)
+ }
+ }
+ is CallAction.Disconnect -> {
+ val call = currentCall.value as? Call.Registered
+ if (call != null) {
+ _currentCall.value =
+ Call.Unregistered(call.id, call.callAttributes, action.cause)
+ // In legacy mode, all actions are initiated from the app
+ listener?.onIsCallDisconnected(call.id, action.cause, CallRepository.EventSource.APP)
+ }
+ }
+ is CallAction.ToggleMute -> {
+ updateCurrentCall { copy(isMuted = action.isMute) }
+ }
+ // Handle other actions...
+ else -> {
+ /* No-op for unsupported actions */
+ }
+ }
+ }
+
+ private fun updateCurrentCall(transform: Call.Registered.() -> Call) {
+ val currentState = _currentCall.value
+ Log.d(
+ TAG,
+ "[repository] updateCurrentCall: Current call state: ${currentState::class.simpleName}"
+ )
+
+ _currentCall.update { call ->
+ if (call is Call.Registered) {
+ val updated = call.transform()
+ Log.d(
+ TAG,
+ "[repository] updateCurrentCall: Call state updated to: ${updated::class.simpleName}"
+ )
+ updated
+ } else {
+ Log.w(
+ TAG,
+ "[repository] updateCurrentCall: Call is not Registered, skipping update"
+ )
+ call
+ }
+ }
+ }
+
+ private fun createCallAttributes(
+ displayName: String,
+ address: Uri,
+ isIncoming: Boolean,
+ isVideo: Boolean
+ ): CallAttributesCompat {
+ Log.d(
+ TAG,
+ "createCallAttributes: Creating CallAttributes - Direction: ${if (isIncoming) "Incoming" else "Outgoing"}, Type: ${if (isVideo) "Video" else "Audio"}"
+ )
+ return CallAttributesCompat(
+ displayName = displayName,
+ address = address,
+ direction =
+ if (isIncoming) {
+ CallAttributesCompat.DIRECTION_INCOMING
+ } else {
+ CallAttributesCompat.DIRECTION_OUTGOING
+ },
+ callType =
+ if (isVideo) {
+ CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+ } else {
+ CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+ },
+ callCapabilities =
+ CallAttributesCompat.SUPPORTS_SET_INACTIVE or
+ CallAttributesCompat.SUPPORTS_STREAM or
+ CallAttributesCompat.SUPPORTS_TRANSFER,
+ )
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/java/com/callingx/repo/TelecomCallRepository.kt b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/TelecomCallRepository.kt
new file mode 100644
index 0000000000..2efeb1e226
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/java/com/callingx/repo/TelecomCallRepository.kt
@@ -0,0 +1,469 @@
+package com.callingx.repo
+
+import CallRepository
+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 com.callingx.model.Call
+import com.callingx.model.CallAction
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.scan
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/**
+ * 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(private val context: Context) : CallRepository {
+
+ companion object {
+ private const val TAG = "[Callingx] TelecomCallRepository"
+ }
+
+ private var listener: CallRepository.Listener? = null
+ private var observeCallStateJob: Job? = null
+
+ private val callsManager: CallsManager
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+ private var isSelfAnswered = false
+ private var isSelfDisconnected = false
+
+ // Keeps track of the current TelecomCall state
+ private val _currentCall: MutableStateFlow = MutableStateFlow(Call.None)
+ override val currentCall = _currentCall.asStateFlow()
+
+ init {
+ val capabilities =
+ CallsManager.CAPABILITY_SUPPORTS_CALL_STREAMING and
+ CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING
+ callsManager =
+ CallsManager(context.applicationContext).apply {
+ registerAppWithTelecom(capabilities)
+ }
+ Log.d(TAG, "[repository] init: CallsManager created and registered")
+ }
+
+ override fun setListener(listener: CallRepository.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?,
+ ) {
+ Log.d(
+ TAG,
+ "[repository] registerCall: Starting registration - Name: $displayName, Address: $address, Incoming: $isIncoming"
+ )
+
+ // For simplicity we don't support multiple calls
+ check(_currentCall.value !is Call.Registered) {
+ "There cannot be more than one call at the same time."
+ }
+ Log.d(
+ TAG,
+ "[repository] registerCall: No existing call found, proceeding with registration"
+ )
+
+ val attributes = createCallAttributes(displayName, address, isIncoming, isVideo)
+ val actionSource = Channel()
+
+ // 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
+ ) {
+ Log.d(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
+ Log.d(
+ 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,
+ )
+ Log.d(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) } } }
+ }
+ Log.d(TAG, "[repository] registerCall: Call successfully registered with Telecom SDK")
+ } catch (e: Exception) {
+ Log.e(TAG, "[repository] registerCall: Error registering call", e)
+ throw e
+ } finally {
+ Log.d(TAG, "[repository] registerCall: Call scope ended, setting state to None")
+ _currentCall.value = Call.None
+ }
+ }
+
+ private fun observeCallState(): Job {
+ return currentCall
+ .scan(Pair(null, currentCall.value)) { (_, prev), next ->
+ Pair(prev, next)
+ }
+ .onEach { (previous, current) ->
+ when {
+ previous is Call.None && current is Call.Registered -> {
+ if (!(current as Call.Registered).isIncoming()) {
+ listener?.onCallRegistered(current.id)
+ }
+ }
+ previous is Call.Registered && current is Call.Registered -> {
+ if (previous.isMuted != current.isMuted) {
+ Log.d(
+ 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) {
+ actionSource.collect { action ->
+ Log.d(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 -> {
+ Log.d(
+ 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.
+ Log.d(TAG, "[repository] processCallActions: Toggling mute: ${action.isMute}")
+ updateCurrentCall {
+ val newMutedState = action.isMute
+ copy(isMuted = newMutedState)
+ }
+ }
+ }
+ }
+ Log.d(TAG, "[repository] processCallActions: Action collection ended")
+ }
+
+ /**
+ * Update the current state of our call applying the transform lambda only if the call is
+ * registered. Otherwise keep the current state
+ */
+ private fun updateCurrentCall(transform: Call.Registered.() -> Call) {
+ val currentState = _currentCall.value
+ Log.d(
+ TAG,
+ "[repository] updateCurrentCall: Current call state: ${currentState::class.simpleName}"
+ )
+ _currentCall.update { call ->
+ if (call is Call.Registered) {
+ val updated = call.transform()
+ Log.d(
+ TAG,
+ "[repository] updateCurrentCall: Call state updated to: ${updated::class.simpleName}"
+ )
+ updated
+ } else {
+ Log.w(
+ TAG,
+ "[repository] updateCurrentCall: Call is not Registered, skipping update"
+ )
+ call
+ }
+ }
+ }
+
+ private suspend fun CallControlScope.doSwitchEndpoint(action: CallAction.SwitchAudioEndpoint) {
+ Log.d(TAG, "[repository] doSwitchEndpoint: Switching to endpoint: ${action.endpointId}")
+ // 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) {
+ Log.d(
+ TAG,
+ "[repository] doSwitchEndpoint: Found endpoint: ${newEndpoint.name}, requesting change"
+ )
+ requestEndpointChange(newEndpoint).also {
+ Log.d(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
+ Log.d(TAG, "[repository] doDisconnect: Disconnecting call with cause: ${action.cause}")
+ disconnect(action.cause)
+ Log.d(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 = {
+ Log.d(TAG, "[repository] onIsCallAnswered: Call answered, type: $it, isSelfAnswered: $isSelfAnswered")
+ updateCurrentCall { copy(isActive = true, isOnHold = false) }
+
+ val call = _currentCall.value
+ val source = if (isSelfAnswered) CallRepository.EventSource.APP else CallRepository.EventSource.SYS
+ if (call is Call.Registered) {
+ listener?.onIsCallAnswered(call.id, source)
+ }
+ isSelfAnswered = false
+ Log.d(TAG, "[repository] onIsCallAnswered: Call state updated to active")
+ }
+
+ /** Can the call perform a disconnect */
+ val onIsCallDisconnected: suspend (cause: DisconnectCause) -> Unit = {
+ Log.d(
+ TAG,
+ "[repository] onIsCallDisconnected: Call disconnected, cause: ${it.reason}, description: ${it.description}"
+ )
+ val source = if (isSelfDisconnected) CallRepository.EventSource.APP else CallRepository.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
+ Log.d(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 = {
+ Log.d(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)
+ }
+ Log.d(TAG, "[repository] onIsCallActive: Call state updated")
+ }
+
+ /** Check to see if we can make the call inactivate */
+ val onIsCallInactive: suspend () -> Unit = {
+ Log.d(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)
+ }
+ Log.d(TAG, "[repository] onIsCallInactive: Call state updated to on hold")
+ }
+
+ private fun createCallAttributes(
+ displayName: String,
+ address: Uri,
+ isIncoming: Boolean,
+ isVideo: Boolean
+ ): CallAttributesCompat {
+ Log.d(
+ TAG,
+ "createCallAttributes: Creating CallAttributes - Direction: ${if (isIncoming) "Incoming" else "Outgoing"}, Type: ${if (isVideo) "Video" else "Audio"}"
+ )
+ return CallAttributesCompat(
+ displayName = displayName,
+ address = address,
+ direction =
+ if (isIncoming) {
+ CallAttributesCompat.DIRECTION_INCOMING
+ } else {
+ CallAttributesCompat.DIRECTION_OUTGOING
+ },
+ callType =
+ if (isVideo) {
+ CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+ } else {
+ CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+ },
+ callCapabilities =
+ CallAttributesCompat.SUPPORTS_SET_INACTIVE or
+ CallAttributesCompat.SUPPORTS_STREAM or
+ CallAttributesCompat.SUPPORTS_TRANSFER,
+ )
+ }
+}
diff --git a/packages/react-native-callingx/android/src/main/res/drawable/ic_phone_paused_24.xml b/packages/react-native-callingx/android/src/main/res/drawable/ic_phone_paused_24.xml
new file mode 100644
index 0000000000..7773fecd3e
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/res/drawable/ic_phone_paused_24.xml
@@ -0,0 +1,11 @@
+
+
+
diff --git a/packages/react-native-callingx/android/src/main/res/drawable/ic_round_call_24.xml b/packages/react-native-callingx/android/src/main/res/drawable/ic_round_call_24.xml
new file mode 100644
index 0000000000..3daf420f62
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/res/drawable/ic_round_call_24.xml
@@ -0,0 +1,11 @@
+
+
+
diff --git a/packages/react-native-callingx/android/src/main/res/drawable/ic_user.xml b/packages/react-native-callingx/android/src/main/res/drawable/ic_user.xml
new file mode 100644
index 0000000000..eaaa2941f8
--- /dev/null
+++ b/packages/react-native-callingx/android/src/main/res/drawable/ic_user.xml
@@ -0,0 +1,27 @@
+
+
+
+
+
diff --git a/packages/react-native-callingx/babel.config.js b/packages/react-native-callingx/babel.config.js
new file mode 100644
index 0000000000..0c05fd6963
--- /dev/null
+++ b/packages/react-native-callingx/babel.config.js
@@ -0,0 +1,12 @@
+module.exports = {
+ overrides: [
+ {
+ exclude: /\/node_modules\//,
+ presets: ['module:react-native-builder-bob/babel-preset'],
+ },
+ {
+ include: /\/node_modules\//,
+ presets: ['module:@react-native/babel-preset'],
+ },
+ ],
+};
diff --git a/packages/react-native-callingx/eslint.config.mjs b/packages/react-native-callingx/eslint.config.mjs
new file mode 100644
index 0000000000..16b00bbcd9
--- /dev/null
+++ b/packages/react-native-callingx/eslint.config.mjs
@@ -0,0 +1,29 @@
+import { fixupConfigRules } from '@eslint/compat';
+import { FlatCompat } from '@eslint/eslintrc';
+import js from '@eslint/js';
+import prettier from 'eslint-plugin-prettier';
+import { defineConfig } from 'eslint/config';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+ baseDirectory: __dirname,
+ recommendedConfig: js.configs.recommended,
+ allConfig: js.configs.all,
+});
+
+export default defineConfig([
+ {
+ extends: fixupConfigRules(compat.extends('@react-native', 'prettier')),
+ plugins: { prettier },
+ rules: {
+ 'react/react-in-jsx-scope': 'off',
+ 'prettier/prettier': 'error',
+ },
+ },
+ {
+ ignores: ['node_modules/', 'lib/'],
+ },
+]);
diff --git a/packages/react-native-callingx/example/.bundle/config b/packages/react-native-callingx/example/.bundle/config
new file mode 100644
index 0000000000..848943bb52
--- /dev/null
+++ b/packages/react-native-callingx/example/.bundle/config
@@ -0,0 +1,2 @@
+BUNDLE_PATH: "vendor/bundle"
+BUNDLE_FORCE_RUBY_PLATFORM: 1
diff --git a/packages/react-native-callingx/example/.watchmanconfig b/packages/react-native-callingx/example/.watchmanconfig
new file mode 100644
index 0000000000..0967ef424b
--- /dev/null
+++ b/packages/react-native-callingx/example/.watchmanconfig
@@ -0,0 +1 @@
+{}
diff --git a/packages/react-native-callingx/example/Gemfile b/packages/react-native-callingx/example/Gemfile
new file mode 100644
index 0000000000..6a4c5f1718
--- /dev/null
+++ b/packages/react-native-callingx/example/Gemfile
@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# You may use http://rbenv.org/ or https://rvm.io/ to install and use this version
+ruby ">= 2.6.10"
+
+# Exclude problematic versions of cocoapods and activesupport that causes build failures.
+gem 'cocoapods', '>= 1.13', '!= 1.15.0', '!= 1.15.1'
+gem 'activesupport', '>= 6.1.7.5', '!= 7.1.0'
+gem 'xcodeproj', '< 1.26.0'
+gem 'concurrent-ruby', '< 1.3.4'
+
+# Ruby 3.4.0 has removed some libraries from the standard library.
+gem 'bigdecimal'
+gem 'logger'
+gem 'benchmark'
+gem 'mutex_m'
diff --git a/packages/react-native-callingx/example/README.md b/packages/react-native-callingx/example/README.md
new file mode 100644
index 0000000000..3e2c3f8505
--- /dev/null
+++ b/packages/react-native-callingx/example/README.md
@@ -0,0 +1,97 @@
+This is a new [**React Native**](https://reactnative.dev) project, bootstrapped using [`@react-native-community/cli`](https://github.com/react-native-community/cli).
+
+# Getting Started
+
+> **Note**: Make sure you have completed the [Set Up Your Environment](https://reactnative.dev/docs/set-up-your-environment) guide before proceeding.
+
+## Step 1: Start Metro
+
+First, you will need to run **Metro**, the JavaScript build tool for React Native.
+
+To start the Metro dev server, run the following command from the root of your React Native project:
+
+```sh
+# Using npm
+npm start
+
+# OR using Yarn
+yarn start
+```
+
+## Step 2: Build and run your app
+
+With Metro running, open a new terminal window/pane from the root of your React Native project, and use one of the following commands to build and run your Android or iOS app:
+
+### Android
+
+```sh
+# Using npm
+npm run android
+
+# OR using Yarn
+yarn android
+```
+
+### iOS
+
+For iOS, remember to install CocoaPods dependencies (this only needs to be run on first clone or after updating native deps).
+
+The first time you create a new project, run the Ruby bundler to install CocoaPods itself:
+
+```sh
+bundle install
+```
+
+Then, and every time you update your native dependencies, run:
+
+```sh
+bundle exec pod install
+```
+
+For more information, please visit [CocoaPods Getting Started guide](https://guides.cocoapods.org/using/getting-started.html).
+
+```sh
+# Using npm
+npm run ios
+
+# OR using Yarn
+yarn ios
+```
+
+If everything is set up correctly, you should see your new app running in the Android Emulator, iOS Simulator, or your connected device.
+
+This is one way to run your app — you can also build it directly from Android Studio or Xcode.
+
+## Step 3: Modify your app
+
+Now that you have successfully run the app, let's make changes!
+
+Open `App.tsx` in your text editor of choice and make some changes. When you save, your app will automatically update and reflect these changes — this is powered by [Fast Refresh](https://reactnative.dev/docs/fast-refresh).
+
+When you want to forcefully reload, for example to reset the state of your app, you can perform a full reload:
+
+- **Android**: Press the R key twice or select **"Reload"** from the **Dev Menu**, accessed via Ctrl + M (Windows/Linux) or Cmd ⌘ + M (macOS).
+- **iOS**: Press R in iOS Simulator.
+
+## Congratulations! :tada:
+
+You've successfully run and modified your React Native App. :partying_face:
+
+### Now what?
+
+- If you want to add this new React Native code to an existing application, check out the [Integration guide](https://reactnative.dev/docs/integration-with-existing-apps).
+- If you're curious to learn more about React Native, check out the [docs](https://reactnative.dev/docs/getting-started).
+
+# Troubleshooting
+
+If you're having issues getting the above steps to work, see the [Troubleshooting](https://reactnative.dev/docs/troubleshooting) page.
+
+# Learn More
+
+To learn more about React Native, take a look at the following resources:
+
+- [React Native Website](https://reactnative.dev) - learn more about React Native.
+- [Getting Started](https://reactnative.dev/docs/environment-setup) - an **overview** of React Native and how setup your environment.
+- [Learn the Basics](https://reactnative.dev/docs/getting-started) - a **guided tour** of the React Native **basics**.
+- [Blog](https://reactnative.dev/blog) - read the latest official React Native **Blog** posts.
+- [`@facebook/react-native`](https://github.com/facebook/react-native) - the Open Source; GitHub **repository** for React Native.
diff --git a/packages/react-native-callingx/example/android/app/build.gradle b/packages/react-native-callingx/example/android/app/build.gradle
new file mode 100644
index 0000000000..48d74066cf
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/build.gradle
@@ -0,0 +1,119 @@
+apply plugin: "com.android.application"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+/**
+ * This is the configuration block to customize your React Native Android app.
+ * By default you don't need to apply any configuration, just uncomment the lines you need.
+ */
+react {
+ /* Folders */
+ // The root of your project, i.e. where "package.json" lives. Default is '../..'
+ // root = file("../../")
+ // The folder where the react-native NPM package is. Default is ../../node_modules/react-native
+ // reactNativeDir = file("../../node_modules/react-native")
+ // The folder where the react-native Codegen package is. Default is ../../node_modules/@react-native/codegen
+ // codegenDir = file("../../node_modules/@react-native/codegen")
+ // The cli.js file which is the React Native CLI entrypoint. Default is ../../node_modules/react-native/cli.js
+ // cliFile = file("../../node_modules/react-native/cli.js")
+
+ /* Variants */
+ // The list of variants to that are debuggable. For those we're going to
+ // skip the bundling of the JS bundle and the assets. By default is just 'debug'.
+ // If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
+ // debuggableVariants = ["liteDebug", "prodDebug"]
+
+ /* Bundling */
+ // A list containing the node command and its flags. Default is just 'node'.
+ // nodeExecutableAndArgs = ["node"]
+ //
+ // The command to run when bundling. By default is 'bundle'
+ // bundleCommand = "ram-bundle"
+ //
+ // The path to the CLI configuration file. Default is empty.
+ // bundleConfig = file(../rn-cli.config.js)
+ //
+ // The name of the generated asset file containing your JS bundle
+ // bundleAssetName = "MyApplication.android.bundle"
+ //
+ // The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
+ // entryFile = file("../js/MyApplication.android.js")
+ //
+ // A list of extra flags to pass to the 'bundle' commands.
+ // See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
+ // extraPackagerArgs = []
+
+ /* Hermes Commands */
+ // The hermes compiler command to run. By default it is 'hermesc'
+ // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
+ //
+ // The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
+ // hermesFlags = ["-O", "-output-source-map"]
+
+ /* Autolinking */
+ autolinkLibrariesWithApp()
+}
+
+/**
+ * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
+ */
+def enableProguardInReleaseBuilds = false
+
+/**
+ * The preferred build flavor of JavaScriptCore (JSC)
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = io.github.react-native-community:jsc-android-intl:2026004.+`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US. Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'io.github.react-native-community:jsc-android:2026004.+'
+
+android {
+ ndkVersion rootProject.ext.ndkVersion
+ buildToolsVersion rootProject.ext.buildToolsVersion
+ compileSdk rootProject.ext.compileSdkVersion
+
+ namespace "callingx.example"
+ defaultConfig {
+ applicationId "callingx.example"
+ minSdkVersion rootProject.ext.minSdkVersion
+ targetSdkVersion rootProject.ext.targetSdkVersion
+ versionCode 1
+ versionName "1.0"
+ }
+ signingConfigs {
+ debug {
+ storeFile file('debug.keystore')
+ storePassword 'android'
+ keyAlias 'androiddebugkey'
+ keyPassword 'android'
+ }
+ }
+ buildTypes {
+ debug {
+ signingConfig signingConfigs.debug
+ }
+ release {
+ // Caution! In production, you need to generate your own keystore file.
+ // see https://reactnative.dev/docs/signed-apk-android.
+ signingConfig signingConfigs.debug
+ minifyEnabled enableProguardInReleaseBuilds
+ proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+ }
+ }
+}
+
+dependencies {
+ // The version of react-native is set by the React Native Gradle Plugin
+ implementation("com.facebook.react:react-android")
+
+ if (hermesEnabled.toBoolean()) {
+ implementation("com.facebook.react:hermes-android")
+ } else {
+ implementation jscFlavor
+ }
+}
diff --git a/packages/react-native-callingx/example/android/app/debug.keystore b/packages/react-native-callingx/example/android/app/debug.keystore
new file mode 100644
index 0000000000..364e105ed3
Binary files /dev/null and b/packages/react-native-callingx/example/android/app/debug.keystore differ
diff --git a/packages/react-native-callingx/example/android/app/proguard-rules.pro b/packages/react-native-callingx/example/android/app/proguard-rules.pro
new file mode 100644
index 0000000000..11b025724a
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/proguard-rules.pro
@@ -0,0 +1,10 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
diff --git a/packages/react-native-callingx/example/android/app/src/debug/AndroidManifest.xml b/packages/react-native-callingx/example/android/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000000..eb98c01afd
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
diff --git a/packages/react-native-callingx/example/android/app/src/main/AndroidManifest.xml b/packages/react-native-callingx/example/android/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..e1892528b8
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/src/main/AndroidManifest.xml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainActivity.kt b/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainActivity.kt
new file mode 100644
index 0000000000..bfa630a644
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainActivity.kt
@@ -0,0 +1,22 @@
+package callingx.example
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+
+class MainActivity : ReactActivity() {
+
+ /**
+ * Returns the name of the main component registered from JavaScript. This is used to schedule
+ * rendering of the component.
+ */
+ override fun getMainComponentName(): String = "CallingxExample"
+
+ /**
+ * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
+ * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
+ */
+ override fun createReactActivityDelegate(): ReactActivityDelegate =
+ DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
+}
diff --git a/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainApplication.kt b/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainApplication.kt
new file mode 100644
index 0000000000..c2529473dc
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/src/main/java/callingx/example/MainApplication.kt
@@ -0,0 +1,38 @@
+package callingx.example
+
+import android.app.Application
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+
+class MainApplication : Application(), ReactApplication {
+
+ override val reactNativeHost: ReactNativeHost =
+ object : DefaultReactNativeHost(this) {
+ override fun getPackages(): List =
+ PackageList(this).packages.apply {
+ // Packages that cannot be autolinked yet can be added manually here, for example:
+ // add(MyReactNativePackage())
+ }
+
+ override fun getJSMainModuleName(): String = "index"
+
+ override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+ override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+ override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+ }
+
+ override val reactHost: ReactHost
+ get() = getDefaultReactHost(applicationContext, reactNativeHost)
+
+ override fun onCreate() {
+ super.onCreate()
+ loadReactNative(this)
+ }
+}
diff --git a/packages/react-native-callingx/example/android/app/src/main/res/drawable/rn_edit_text_material.xml b/packages/react-native-callingx/example/android/app/src/main/res/drawable/rn_edit_text_material.xml
new file mode 100644
index 0000000000..5c25e728ea
--- /dev/null
+++ b/packages/react-native-callingx/example/android/app/src/main/res/drawable/rn_edit_text_material.xml
@@ -0,0 +1,37 @@
+
+
+
+
+
+
+