@cometchat/calls-sdk-react-native 4.4.2-beta.1 → 5.0.0-beta.1

package/README.md

@@ -1,31 +1,97 @@
-<p align="center">
-  <img alt="CometChat" src="https://assets.cometchat.io/website/images/logos/banner.png">
-</p>
+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
 
-# CometChat React Native Calls SDK
+> **Note**: Make sure you have completed the [Set Up Your Environment](https://reactnative.dev/docs/set-up-your-environment) guide before proceeding.
 
-CometChat enables you to add voice, video & text chat for your website & app.
-___
+## Step 1: Start Metro
 
-## Prerequisites :star:
+First, you will need to run **Metro**, the JavaScript build tool for React Native.
 
-Before starting, ensure you have set up your React Native development environment correctly by following the guide at https://reactnative.dev/docs/environment-setup
+To start the Metro dev server, run the following command from the root of your React Native project:
 
-___
+```sh
+# Using npm
+npm start
 
-## Setting up React Native Calls SDK
-Follow the official React Native Calls SDK setup guide in our documentation:
-https://www.cometchat.com/docs/sdk/react-native/overview
+# OR using Yarn
+yarn start
+```
 
----
+## Step 2: Build and run your app
 
-## Checkout our sample apps
-Explore our React Native sample apps & UI Kit examples here:
-https://github.com/cometchat/cometchat-uikit-react-native/tree/v5/examples
+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
 
-## Help and Support
-For issues running the project or integrating with our UI Kits, consult our [documentation](https://www.cometchat.com/docs) or create a [support ticket](https://help.cometchat.com/hc/en-us) or seek real-time support via the [CometChat Dashboard](https://app.cometchat.com/).
+# 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 <kbd>R</kbd> key twice or select **"Reload"** from the **Dev Menu**, accessed via <kbd>Ctrl</kbd> + <kbd>M</kbd> (Windows/Linux) or <kbd>Cmd ⌘</kbd> + <kbd>M</kbd> (macOS).
+- **iOS**: Press <kbd>R</kbd> 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.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Tue Nov 25 14:33:26 IST 2025
+gradle.version=8.9

package/android/build.gradle

@@ -1,20 +1,21 @@
 apply plugin: 'com.android.library'
 
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 28)
-    
+    namespace "com.cometchat.calls"
+    compileSdkVersion rootProject.ext.compileSdkVersion
+
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 16)
-        targetSdkVersion safeExtGet('targetSdkVersion', 28)
-        versionCode 1
-        versionName "1.0"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+        }
     }
 }
 
 dependencies {
-    implementation 'com.facebook.react:react-native:+'
-}
+    implementation "com.facebook.react:react-native:+"
+}

package/android/src/main/AndroidManifest.xml

@@ -1,8 +1,17 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.cometchat.calls">
 
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.CometChatCalls">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.CAMERA" />
-    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
-    <uses-permission android:name="android.permission.RECORD_AUDIO" />
-    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.BLUETOOTH" />
+  <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 </manifest>

package/android/src/main/java/com/callingv5/AudioDeviceHandlerConnectionService.java

@@ -0,0 +1,185 @@
+/*
+      * Copyright @ 2017-present 8x8, Inc.
+      *
+      * 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
+      *
+      *     http://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.cometchat.calls;
+
+import android.media.AudioManager;
+import android.os.Build;
+import android.telecom.CallAudioState;
+
+import androidx.annotation.RequiresApi;
+
+import com.cometchat.calls.utils.CometChatLogger;
+
+import java.util.HashSet;
+import java.util.Set;
+
+
+     /**
+      * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
+      * Android versions >= O when ConnectionService is enabled.
+      */
+     @RequiresApi(Build.VERSION_CODES.O)
+     class AudioDeviceHandlerConnectionService implements
+             AudioModeModule.AudioDeviceHandlerInterface,
+             RNConnectionService.CallAudioStateListener {
+
+         private final static String TAG = AudioDeviceHandlerConnectionService.class.getSimpleName();
+
+         /**
+          * {@link AudioManager} instance used to interact with the Android audio subsystem.
+          */
+         private AudioManager audioManager;
+
+         /**
+          * Reference to the main {@code AudioModeModule}.
+          */
+         private AudioModeModule module;
+
+         private RNConnectionService rcs;
+
+         /**
+          * Converts any of the "DEVICE_" constants into the corresponding
+          * {@link CallAudioState} "ROUTE_" number.
+          *
+          * @param audioDevice one of the "DEVICE_" constants.
+          * @return a route number {@link CallAudioState#ROUTE_EARPIECE} if
+          * no match is found.
+          */
+         private static int audioDeviceToRouteInt(String audioDevice) {
+             if (audioDevice == null) {
+                 return CallAudioState.ROUTE_SPEAKER;
+             }
+             switch (audioDevice) {
+                 case AudioModeModule.DEVICE_BLUETOOTH:
+                     return CallAudioState.ROUTE_BLUETOOTH;
+                 case AudioModeModule.DEVICE_EARPIECE:
+                     return CallAudioState.ROUTE_EARPIECE;
+                 case AudioModeModule.DEVICE_HEADPHONES:
+                     return CallAudioState.ROUTE_WIRED_HEADSET;
+                 case AudioModeModule.DEVICE_SPEAKER:
+                     return CallAudioState.ROUTE_SPEAKER;
+                 default:
+                     CometChatLogger.e(TAG, "Unsupported device name: " + audioDevice);
+                     return CallAudioState.ROUTE_SPEAKER;
+             }
+         }
+
+         /**
+          * Populates given route mask into the "DEVICE_" list.
+          *
+          * @param supportedRouteMask an integer coming from
+          * {@link CallAudioState#getSupportedRouteMask()}.
+          * @return a list of device names.
+          */
+         private static Set<String> routesToDeviceNames(int supportedRouteMask) {
+             Set<String> devices = new HashSet<>();
+             if ((supportedRouteMask & CallAudioState.ROUTE_EARPIECE) == CallAudioState.ROUTE_EARPIECE) {
+                 devices.add(AudioModeModule.DEVICE_EARPIECE);
+             }
+             if ((supportedRouteMask & CallAudioState.ROUTE_BLUETOOTH) == CallAudioState.ROUTE_BLUETOOTH) {
+                 devices.add(AudioModeModule.DEVICE_BLUETOOTH);
+             }
+             if ((supportedRouteMask & CallAudioState.ROUTE_SPEAKER) == CallAudioState.ROUTE_SPEAKER) {
+                 devices.add(AudioModeModule.DEVICE_SPEAKER);
+             }
+             if ((supportedRouteMask & CallAudioState.ROUTE_WIRED_HEADSET) == CallAudioState.ROUTE_WIRED_HEADSET) {
+                 devices.add(AudioModeModule.DEVICE_HEADPHONES);
+             }
+             return devices;
+         }
+
+         /**
+          * Used to store the most recently reported audio devices.
+          * Makes it easier to compare for a change, because the devices are stored
+          * as a mask in the {@link CallAudioState}. The mask is populated into
+          * the {@code availableDevices} on each update.
+          */
+         private int supportedRouteMask = -1;
+
+         public AudioDeviceHandlerConnectionService(AudioManager audioManager) {
+             this.audioManager = audioManager;
+         }
+
+         @Override
+         public void onCallAudioStateChange(final CallAudioState state) {
+             module.runInAudioThread(new Runnable() {
+                 @Override
+                 public void run() {
+                     boolean audioRouteChanged
+                         = audioDeviceToRouteInt(module.getSelectedDevice()) != state.getRoute();
+                     int newSupportedRoutes = state.getSupportedRouteMask();
+                     boolean audioDevicesChanged = supportedRouteMask != newSupportedRoutes;
+                     if (audioDevicesChanged) {
+                         supportedRouteMask = newSupportedRoutes;
+                         Set<String> devices = routesToDeviceNames(supportedRouteMask);
+                         module.replaceDevices(devices);
+                         CometChatLogger.i(TAG, "Available audio devices: " + devices.toString());
+                     }
+
+                     if (audioRouteChanged || audioDevicesChanged) {
+                         module.resetSelectedDevice();
+                         module.updateAudioRoute();
+                     }
+                 }
+             });
+         }
+
+         @Override
+         public void start(AudioModeModule audioModeModule) {
+             CometChatLogger.i(TAG, "Using " + TAG + " as the audio device handler");
+
+             module = audioModeModule;
+             rcs = module.getContext().getNativeModule(RNConnectionService.class);
+
+             if (rcs != null) {
+                 rcs.setCallAudioStateListener(this);
+             } else {
+                 CometChatLogger.w(TAG, "Couldn't set call audio state listener, module is null");
+             }
+         }
+
+         @Override
+         public void stop() {
+             if (rcs != null) {
+                 rcs.setCallAudioStateListener(null);
+                 rcs = null;
+             } else {
+                 CometChatLogger.w(TAG, "Couldn't set call audio state listener, module is null");
+             }
+         }
+
+         public void setAudioRoute(String audioDevice) {
+             int newAudioRoute = audioDeviceToRouteInt(audioDevice);
+
+             RNConnectionService.setAudioRoute(newAudioRoute);
+         }
+
+         @Override
+         public boolean setMode(int mode) {
+             if (mode != AudioModeModule.DEFAULT) {
+                 // This shouldn't be needed when using ConnectionService, but some devices have been
+                 // observed not doing it.
+                 try {
+                     audioManager.setMicrophoneMute(false);
+                 } catch (Throwable tr) {
+                     CometChatLogger.w(TAG, "Failed to unmute the microphone");
+                 }
+             }
+
+             return true;
+         }
+     }

package/android/src/main/java/com/callingv5/AudioDeviceHandlerGeneric.java

@@ -0,0 +1,254 @@
+/*
+  * Copyright @ 2017-present 8x8, Inc.
+  *
+  * 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
+  *
+  *     http://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.cometchat.calls;
+
+import android.media.AudioAttributes;
+import android.media.AudioDeviceInfo;
+import android.media.AudioFocusRequest;
+import android.media.AudioManager;
+import android.os.Build;
+
+import com.cometchat.calls.utils.CometChatLogger;
+
+import java.util.HashSet;
+import java.util.Set;
+
+
+ /**
+  * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
+  * all post-M Android versions. This handler can be used on any Android versions >= M, but by
+  * default it's only used on versions < O, since versions >= O use ConnectionService, but it
+  * can be disabled.
+  */
+ class AudioDeviceHandlerGeneric implements
+         AudioModeModule.AudioDeviceHandlerInterface,
+         AudioManager.OnAudioFocusChangeListener {
+
+     private final static String TAG = AudioDeviceHandlerGeneric.class.getSimpleName();
+
+     /**
+      * Reference to the main {@code AudioModeModule}.
+      */
+     private AudioModeModule module;
+
+     /**
+      * Constant defining a Hearing Aid. Only available on API level >= 28.
+      * The value of: AudioDeviceInfo.TYPE_HEARING_AID
+      */
+     private static final int TYPE_HEARING_AID = 23;
+
+     /**
+      * Constant defining a USB headset. Only available on API level >= 26.
+      * The value of: AudioDeviceInfo.TYPE_USB_HEADSET
+      */
+     private static final int TYPE_USB_HEADSET = 22;
+
+     /**
+      * Indicator that we have lost audio focus.
+      */
+     private boolean audioFocusLost = false;
+
+     /**
+      * {@link AudioManager} instance used to interact with the Android audio
+      * subsystem.
+      */
+     private AudioManager audioManager;
+
+     /**
+      * {@link Runnable} for running audio device detection in the audio thread.
+      * This is only used on Android >= M.
+      */
+     private final Runnable onAudioDeviceChangeRunner = new Runnable() {
+         @Override
+         public void run() {
+             Set<String> devices = new HashSet<>();
+             AudioDeviceInfo[] deviceInfos = audioManager.getDevices( AudioManager.GET_DEVICES_INPUTS | AudioManager.GET_DEVICES_OUTPUTS);
+
+             for (AudioDeviceInfo info: deviceInfos) {
+                 switch (info.getType()) {
+                     case AudioDeviceInfo.TYPE_BLUETOOTH_SCO:
+                         devices.add(AudioModeModule.DEVICE_BLUETOOTH);
+                         break;
+                     case AudioDeviceInfo.TYPE_BUILTIN_EARPIECE:
+                         devices.add(AudioModeModule.DEVICE_EARPIECE);
+                         break;
+                     case AudioDeviceInfo.TYPE_BUILTIN_SPEAKER:
+                     case AudioDeviceInfo.TYPE_HDMI:
+                         devices.add(AudioModeModule.DEVICE_SPEAKER);
+                         break;
+                     case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
+                     case AudioDeviceInfo.TYPE_WIRED_HEADSET:
+                     case TYPE_HEARING_AID:
+                     case TYPE_USB_HEADSET:
+                         devices.add(AudioModeModule.DEVICE_HEADPHONES);
+                         break;
+                 }
+             }
+
+             module.replaceDevices(devices);
+
+             CometChatLogger.i(TAG, "Available audio devices: " + devices.toString());
+
+             module.updateAudioRoute();
+         }
+     };
+
+     private final android.media.AudioDeviceCallback audioDeviceCallback =
+         new android.media.AudioDeviceCallback() {
+             @Override
+             public void onAudioDevicesAdded(
+                 AudioDeviceInfo[] addedDevices) {
+                 CometChatLogger.d(TAG, "Audio devices added");
+                 onAudioDeviceChange();
+             }
+
+             @Override
+             public void onAudioDevicesRemoved(
+                 AudioDeviceInfo[] removedDevices) {
+                 CometChatLogger.d(TAG, "Audio devices removed");
+                 onAudioDeviceChange();
+             }
+         };
+
+     public AudioDeviceHandlerGeneric(AudioManager audioManager) {
+         this.audioManager = audioManager;
+     }
+
+     /**
+      * Helper method to trigger an audio route update when devices change. It
+      * makes sure the operation is performed on the audio thread.
+      */
+     private void onAudioDeviceChange() {
+         module.runInAudioThread(onAudioDeviceChangeRunner);
+     }
+
+     /**
+      * {@link AudioManager.OnAudioFocusChangeListener} interface method. Called
+      * when the audio focus of the system is updated.
+      *
+      * @param focusChange - The type of focus change.
+      */
+     @Override
+     public void onAudioFocusChange(final int focusChange) {
+         module.runInAudioThread(new Runnable() {
+             @Override
+             public void run() {
+                 switch (focusChange) {
+                     case AudioManager.AUDIOFOCUS_GAIN: {
+                         CometChatLogger.d(TAG, "Audio focus gained");
+                         // Some other application potentially stole our audio focus
+                         // temporarily. Restore our mode.
+                         if (audioFocusLost) {
+                             module.resetAudioRoute();
+                         }
+                         audioFocusLost = false;
+                         break;
+                     }
+                     case AudioManager.AUDIOFOCUS_LOSS:
+                     case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
+                     case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
+                         CometChatLogger.d(TAG, "Audio focus lost");
+                         audioFocusLost = true;
+                         break;
+                     }
+                 }
+             }
+         });
+     }
+
+     /**
+      * Helper method to set the output route to a Bluetooth device.
+      *
+      * @param enabled true if Bluetooth should use used, false otherwise.
+      */
+     private void setBluetoothAudioRoute(boolean enabled) {
+         if (enabled) {
+             audioManager.startBluetoothSco();
+             audioManager.setBluetoothScoOn(true);
+         } else {
+             audioManager.setBluetoothScoOn(false);
+             audioManager.stopBluetoothSco();
+         }
+     }
+
+     @Override
+     public void start(AudioModeModule audioModeModule) {
+         CometChatLogger.i(TAG, "Using " + TAG + " as the audio device handler");
+
+         module = audioModeModule;
+
+         // Setup runtime device change detection.
+         audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
+
+         // Do an initial detection.
+         onAudioDeviceChange();
+     }
+
+     @Override
+     public void stop() {
+         audioManager.unregisterAudioDeviceCallback(audioDeviceCallback);
+     }
+
+     @Override
+     public void setAudioRoute(String device) {
+         // Turn speaker on / off
+         audioManager.setSpeakerphoneOn(device.equals(AudioModeModule.DEVICE_SPEAKER));
+
+         // Turn bluetooth on / off
+         setBluetoothAudioRoute(device.equals(AudioModeModule.DEVICE_BLUETOOTH));
+     }
+
+     @Override
+     public boolean setMode(int mode) {
+         if (mode == AudioModeModule.DEFAULT) {
+             audioFocusLost = false;
+             audioManager.setMode(AudioManager.MODE_NORMAL);
+             audioManager.abandonAudioFocus(this);
+             audioManager.setSpeakerphoneOn(false);
+             setBluetoothAudioRoute(false);
+
+             return true;
+         }
+
+         audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
+         audioManager.setMicrophoneMute(false);
+
+         int gotFocus;
+         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+             gotFocus = audioManager.requestAudioFocus(new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                 .setAudioAttributes(
+                     new AudioAttributes.Builder()
+                         .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                         .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                         .build()
+                 )
+                 .setAcceptsDelayedFocusGain(true)
+                 .setOnAudioFocusChangeListener(this)
+                 .build()
+             );
+         } else {
+             gotFocus = audioManager.requestAudioFocus(this, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN);
+         }
+
+         if (gotFocus == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+             CometChatLogger.w(TAG, "Audio focus request failed");
+             return false;
+         }
+
+         return true;
+     }
+ }