rns-nativecall 0.0.1

package/README.md

@@ -0,0 +1,192 @@
+# RNS Native Call
+
+RNS Native Call is a React Native package that provides fully native VoIP call handling on Android and iOS. It supports self-managed calls, custom ringtone handling, video calls, and allows dismissing native call UI programmatically. Fully TypeScript-ready.
+
+---
+
+## Features
+
+* Display incoming calls with native UI.
+* Support for video and audio calls.
+* Self-managed calls on Android (prevents polluting the device call log).
+* Prevents iOS call log from being saved using `includesCallsInRecents = NO`.
+* Control ringtone per call.
+* Subscribe to call events (accepted, rejected, failed).
+* Cross-platform (Android & iOS) ready.
+* TypeScript types included.
+
+---
+
+## Installation
+
+```bash
+npm install rns-nativecall
+# or
+yarn add rns-nativecall
+```
+
+---
+
+## Expo Integration
+
+If you are using **Expo managed workflow**, the package provides a plugin that automatically modifies the `AndroidManifest.xml` for required permissions and services.
+
+In your `app.json` / `app.config.js`:
+
+```js
+import withRaiidrVoip from 'rns-nativecall/withRaiidrVoip';
+
+export default {
+  expo: {
+    name: 'YourApp',
+    slug: 'your-app',
+    plugins: [
+      withRaiidrVoip
+    ],
+  },
+};
+```
+
+> The plugin ensures the following Android permissions are added automatically:
+>
+> ```xml
+> <uses-permission android:name="android.permission.READ_PHONE_NUMBERS"/>
+> <uses-permission android:name="android.permission.CALL_PHONE"/>
+> ```
+>
+> It also registers the `MyConnectionService` for Telecom integration:
+>
+> ```xml
+> <service
+>     android:name="com.rnsnativecall.MyConnectionService"
+>     android:permission="android.permission.BIND_CONNECTION_SERVICE"
+>     android:exported="true">
+>     <intent-filter>
+>         <action android:name="android.telecom.ConnectionService"/>
+>     </intent-filter>
+> </service>
+> ```
+
+---
+
+## iOS Setup
+
+1. Make sure you have the pod installed:
+
+```bash
+cd ios
+pod install
+```
+
+2. CallKit is automatically used, and call log entries are prevented using:
+
+```objc
+config.includesCallsInRecents = NO;
+```
+
+> The native iOS module handles showing the call UI and managing call events.
+
+---
+
+## Usage
+
+```ts
+import CallHandler from 'rns-nativecall';
+
+// Subscribe to call events
+const unsubscribe = CallHandler.subscribe(
+  (data) => console.log('Call Accepted', data),
+  (data) => console.log('Call Rejected', data),
+  (data) => console.log('Call Failed', data)
+);
+
+// Display an incoming call
+await CallHandler.displayCall(
+  'uuid-string',
+  '+1234567890',
+  'John Doe',
+  true,   // hasVideo
+  true    // shouldRing
+);
+
+// Dismiss call UI programmatically
+CallHandler.destroyNativeCallUI('uuid-string');
+
+// Remove event listeners when done
+unsubscribe();
+```
+
+---
+
+## API
+
+### `displayCall(uuid, number, name, hasVideo?, shouldRing?) => Promise<boolean>`
+
+Displays native incoming call UI.
+
+* **uuid**: Unique call identifier.
+* **number**: Caller number.
+* **name**: Caller display name.
+* **hasVideo**: Boolean, true for video call.
+* **shouldRing**: Boolean, true to play native ringtone.
+
+Returns a promise that resolves to `true` if UI was successfully displayed.
+
+### `destroyNativeCallUI(uuid)`
+
+Dismisses the native call UI.
+
+* **uuid**: Call identifier.
+
+### `subscribe(onAccept, onReject, onFailed) => () => void`
+
+Subscribe to native call events.
+
+* **onAccept**: Callback for accepted calls.
+* **onReject**: Callback for rejected calls.
+* **onFailed**: Optional callback for failed calls.
+
+Returns a function to unsubscribe all listeners.
+
+---
+
+## Permissions
+
+### Android
+
+* `READ_PHONE_NUMBERS`
+* `CALL_PHONE`
+
+The Expo plugin ensures these are automatically added to `AndroidManifest.xml`.
+
+### iOS
+
+* Uses CallKit (`CXProvider`) internally.
+* Prevents call log pollution using `includesCallsInRecents = NO`.
+
+---
+
+## TypeScript Support
+
+Types are included. Example:
+
+```ts
+import CallHandler, { CallData, CallAcceptedCallback } from 'rns-nativecall';
+
+const onAccept: CallAcceptedCallback = (data: CallData) => {
+  console.log('Accepted:', data.callUUID);
+};
+```
+
+---
+
+## Notes
+
+* Android uses `Connection.CAPABILITY_SELF_MANAGED` to prevent calls from showing in the system call log.
+* iOS uses `CXCallEndedReasonRemoteEnded` for clean UI dismissal without showing failed call overlays.
+
+---
+
+## License
+
+MIT

package/android/src/main/java/com/rnsnativecall/CallModule.kt

@@ -0,0 +1,117 @@
+///Users/bush/Desktop/Apps/Raiidr/package/android/src/main/java/com/rnsnativecall/CallModule.kt
+package com.rnsnativecall
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.telecom.PhoneAccount
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.telecom.DisconnectCause
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    init {
+        instance = this
+        registerPhoneAccount()
+    }
+
+    override fun getName() = "CallModule"
+
+    private fun registerPhoneAccount() {
+        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val componentName = ComponentName(reactApplicationContext, MyConnectionService::class.java)
+        val phoneAccountHandle = PhoneAccountHandle(componentName, "RaiidrVoip")
+
+            // Combine all critical capabilities into one mask this is important!!!
+            val capabilities = PhoneAccount.CAPABILITY_VIDEO_CALLING or 
+                               PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING 
+
+            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "Raiidr") 
+                               .setCapabilities(capabilities) 
+                               .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED) 
+                               .setCapabilities(PhoneAccount.CAPABILITY_CALL_PROVIDER) 
+                               .build()
+
+        telecomManager.registerPhoneAccount(phoneAccount)
+    }
+
+    @ReactMethod
+    fun displayIncomingCall(
+        uuid: String,
+        number: String,
+        name: String,
+        hasVideo: Boolean,
+        playRing: Boolean,
+        promise: Promise
+    ) {
+        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val componentName = ComponentName(reactApplicationContext, MyConnectionService::class.java)
+        val phoneAccountHandle = PhoneAccountHandle(componentName, "RaiidrVoip")
+
+        val extras = Bundle().apply {
+            putParcelable(
+                TelecomManager.EXTRA_INCOMING_CALL_ADDRESS,
+                Uri.fromParts("sip", number, null)
+            )
+            putString(TelecomManager.EXTRA_CALL_SUBJECT, name)
+            putString("EXTRA_CALL_UUID", uuid)
+            putBoolean("EXTRA_PLAY_RING", playRing)
+            putBoolean(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, hasVideo)
+        }
+
+        try {
+            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CALL_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun endNativeCall(uuid: String) {
+        val connection = MyConnectionService.getConnection(uuid)
+        connection?.let {
+            it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+            it.destroy()
+            MyConnectionService.removeConnection(uuid)
+        }
+    }
+
+    @ReactMethod
+    fun checkTelecomPermissions(promise: Promise) {
+        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val componentName = ComponentName(reactApplicationContext, MyConnectionService::class.java)
+        val phoneAccountHandle = PhoneAccountHandle(componentName, "RaiidrVoip")
+
+        val account = telecomManager.getPhoneAccount(phoneAccountHandle)
+        if (account != null && account.isEnabled) {
+            promise.resolve(true)
+        } else {
+            val intent = Intent(TelecomManager.ACTION_CHANGE_PHONE_ACCOUNTS)
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            reactApplicationContext.startActivity(intent)
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
+    companion object {
+        private var instance: CallModule? = null
+
+        fun sendEventToJS(eventName: String, uuid: String?) {
+            val params = Arguments.createMap().apply {
+                putString("callUUID", uuid)
+            }
+            instance?.reactApplicationContext
+                ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit(eventName, params)
+        }
+    }
+}

package/android/src/main/java/com/rnsnativecall/CallPackage.kt

@@ -0,0 +1,17 @@
+/////Users/bush/Desktop/Apps/Raiidr/package/android/src/main/java/com/rnsnativecall/CallPackage.kt
+package com.rnsnativecall
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class CallPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(CallModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/com/rnsnativecall/MyCallConnection.kt

@@ -0,0 +1,100 @@
+/////Users/bush/Desktop/Apps/Raiidr/package/android/src/main/java/com/rnsnativecall/MyCallConnection.kt
+package com.rnsnativecall
+
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.MediaPlayer
+import android.media.RingtoneManager
+import android.telecom.Connection
+import android.telecom.DisconnectCause
+
+class MyCallConnection(
+    private val context: Context,
+    private val callUUID: String?,
+    private val playRing: Boolean,
+    private val onAcceptCallback: (String?) -> Unit,
+    private val onRejectCallback: (String?) -> Unit
+) : Connection() {
+
+    private var mediaPlayer: MediaPlayer? = null
+
+    init {
+        connectionProperties = PROPERTY_SELF_MANAGED
+        audioModeIsVoip = true
+
+        if (playRing) {
+            startRingtone()
+        }
+    }
+
+    private fun startRingtone() {
+        val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+
+        mediaPlayer = MediaPlayer().apply {
+            setDataSource(context, uri)
+            setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                    .build()
+            )
+            isLooping = true
+            prepare()
+            start()
+        }
+    }
+
+    private fun stopRingtone() {
+        mediaPlayer?.stop()
+        mediaPlayer?.release()
+        mediaPlayer = null
+    }
+
+    private fun cleanUp() {
+        stopRingtone()
+        callUUID?.let { MyConnectionService.removeConnection(it) }
+    }
+
+    override fun onAnswer() {
+        stopRingtone()
+
+        // Bring app to foreground
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        launchIntent?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            context.startActivity(this)
+        }
+
+        // Notify JS
+        onAcceptCallback(callUUID)
+
+        // 🔥 IMMEDIATELY detach from Telecom
+        setDisconnected(DisconnectCause(DisconnectCause.CANCELED))
+        cleanUp()
+        destroy()
+    }
+
+    override fun onReject() {
+        stopRingtone()
+        setDisconnected(DisconnectCause(DisconnectCause.REJECTED))
+        cleanUp()
+        destroy()
+        onRejectCallback(callUUID)
+    }
+
+    override fun onDisconnect() {
+        stopRingtone()
+        setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+        cleanUp()
+        destroy()
+        onRejectCallback(callUUID)
+    }
+
+    override fun onAbort() {
+        stopRingtone()
+        setDisconnected(DisconnectCause(DisconnectCause.CANCELED))
+        cleanUp()
+        destroy()
+    }
+}

package/android/src/main/java/com/rnsnativecall/MyConnectionService.kt

@@ -0,0 +1,70 @@
+/////Users/bush/Desktop/Apps/Raiidr/package/android/src/main/java/com/rnsnativecall/MyConnectionService.kt
+package com.rnsnativecall
+
+import android.telecom.Connection
+import android.telecom.ConnectionRequest
+import android.telecom.ConnectionService
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import java.util.concurrent.ConcurrentHashMap
+
+class MyConnectionService : ConnectionService() {
+
+    companion object {
+        private val activeConnections = ConcurrentHashMap<String, MyCallConnection>()
+
+        fun getConnection(uuid: String) = activeConnections[uuid]
+        fun addConnection(uuid: String, connection: MyCallConnection) {
+            activeConnections[uuid] = connection
+        }
+        fun removeConnection(uuid: String) {
+            activeConnections.remove(uuid)
+        }
+    }
+
+    override fun onCreateIncomingConnection(
+        connectionManagerPhoneAccount: PhoneAccountHandle?,
+        request: ConnectionRequest?
+    ): Connection {
+
+        // 1️⃣ Read extras FIRST
+        val extras = request?.extras
+        val callUUID = extras?.getString("EXTRA_CALL_UUID")
+        val playRing = extras?.getBoolean("EXTRA_PLAY_RING", true) ?: true
+        val callerName = extras?.getString(TelecomManager.EXTRA_CALL_SUBJECT)
+
+        // 2️⃣ Create connection
+        val connection = MyCallConnection(
+            context = applicationContext,
+            callUUID = callUUID,
+            playRing = playRing,
+            onAcceptCallback = { uuid ->
+                CallModule.sendEventToJS("onCallAccepted", uuid)
+            },
+            onRejectCallback = { uuid ->
+                CallModule.sendEventToJS("onCallRejected", uuid)
+            }
+        )
+
+        // 3️⃣ Set caller display name (THIS FIXES MISALIGNMENT)
+        callerName?.let {
+            connection.setCallerDisplayName(
+                it,
+                TelecomManager.PRESENTATION_ALLOWED
+            )
+        }
+
+        // 4️⃣ Standard Telecom setup
+        connection.connectionCapabilities =
+            Connection.CAPABILITY_MUTE or Connection.CAPABILITY_SUPPORT_HOLD
+
+        connection.setAddress(request?.address, TelecomManager.PRESENTATION_ALLOWED)
+        connection.setInitializing()
+        connection.setRinging()
+
+        // 5️⃣ Track connection
+        callUUID?.let { addConnection(it, connection) }
+
+        return connection
+    }
+}

package/app.plugin.js

@@ -0,0 +1,6 @@
+////Users/bush/Desktop/Apps/Raiidr/package/app.plugin.js
+const withRaiidrVoip = require('./withRaiidrVoip');
+
+module.exports = function (config) {
+    return withRaiidrVoip(config);
+};

package/index.d.ts

@@ -0,0 +1,50 @@
+///Users/bush/Desktop/Apps/Raiidr/package/index.d.ts
+export interface CallData {
+    callUUID: string;
+}
+
+export type CallAcceptedCallback = (data: CallData) => void;
+export type CallRejectedCallback = (data: CallData) => void;
+export type CallFailedCallback = (data: CallData) => void;
+
+export interface CallHandlerType {
+    /**
+     * Display an incoming call UI.
+     * @param uuid Unique call identifier
+     * @param number Caller number
+     * @param name Caller display name
+     * @param hasVideo True if video call
+     * @param shouldRing True to play native ringtone
+     * @returns Promise resolving to true if successfully displayed
+     */
+    displayCall(
+        uuid: string,
+        number: string,
+        name: string,
+        hasVideo?: boolean,
+        shouldRing?: boolean
+    ): Promise<boolean>;
+
+    /**
+     * Dismiss native call UI
+     * @param uuid Call identifier
+     */
+    destroyNativeCallUI(uuid: string): void;
+
+    /**
+     * Subscribe to call events
+     * @param onAccept Callback for accepted calls
+     * @param onReject Callback for rejected calls
+     * @param onFailed Optional callback for failed calls
+     * @returns Function to unsubscribe all listeners
+     */
+    subscribe(
+        onAccept: CallAcceptedCallback,
+        onReject: CallRejectedCallback,
+        onFailed?: CallFailedCallback
+    ): () => void;
+}
+
+declare const CallHandler: CallHandlerType;
+
+export default CallHandler;

package/index.js

@@ -0,0 +1,102 @@
+///Users/bush/Desktop/Apps/Raiidr/package/index.js
+import {
+    NativeModules,
+    NativeEventEmitter,
+    PermissionsAndroid,
+    Platform,
+    Linking,
+    Alert
+} from 'react-native';
+
+const { CallModule } = NativeModules;
+const callEventEmitter = CallModule ? new NativeEventEmitter(CallModule) : null;
+
+const REQUIRED_PERMISSIONS = Platform.OS === 'android' ? [
+    PermissionsAndroid.PERMISSIONS.READ_PHONE_NUMBERS,
+    PermissionsAndroid.PERMISSIONS.CALL_PHONE,
+] : [];
+
+export async function ensureAndroidPermissions() {
+    if (Platform.OS !== 'android') return true;
+    const result = await PermissionsAndroid.requestMultiple(REQUIRED_PERMISSIONS);
+    const deniedPermissions = Object.entries(result)
+        .filter(([_, status]) => status !== PermissionsAndroid.RESULTS.GRANTED)
+        .map(([perm, _]) => perm);
+
+    if (deniedPermissions.length > 0) {
+        Alert.alert(
+            'Permissions Required',
+            `The following permissions are still missing: \n${deniedPermissions.join('\n')}`,
+            [{ text: 'Open Settings', onPress: () => Linking.openSettings() }]
+        );
+        return false;
+    }
+    return true;
+}
+
+export const CallHandler = {
+
+    /**
+     * @param {string} uuid 
+     * @param {string} number 
+     * @param {string} name 
+     * @param {boolean} hasVideo 
+     * @param {boolean} shouldRing - NEW: Controls native ringtone/vibration
+     */
+    displayCall: async (uuid, number, name, hasVideo = false, shouldRing = true) => {
+        if (!CallModule) {
+            console.log("CallModule is null. Check native linking.");
+            return false;
+        }
+
+        // 1. Android Specific Checks
+        if (Platform.OS === 'android') {
+            const hasPerms = await ensureAndroidPermissions();
+            if (!hasPerms) return false;
+
+            const isAccountEnabled = await CallModule.checkTelecomPermissions();
+            if (!isAccountEnabled) return false;
+        }
+
+        const cleanUuid = uuid.toLowerCase().trim();
+
+        // 2. Cross-platform execution
+        try {
+            // We now pass 5 arguments to the native side
+            // uuid, number, name, hasVideo, shouldRing
+            const success = await CallModule.displayIncomingCall(
+                cleanUuid,
+                number,
+                name,
+                hasVideo,
+                shouldRing
+            );
+            return success;
+        } catch (e) {
+            console.log("Native Call Error:", e);
+            return false;
+        }
+    },
+
+    destroyNativeCallUI: (uuid) => {
+        if (CallModule && CallModule.endNativeCall) {
+            CallModule.endNativeCall(uuid.toLowerCase());
+        }
+    },
+
+    subscribe: (onAccept, onReject, onFailed) => {
+        if (!callEventEmitter) {
+            return () => { };
+        }
+
+        const acceptSub = callEventEmitter.addListener('onCallAccepted', (data) => onAccept(data));
+        const rejectSub = callEventEmitter.addListener('onCallRejected', (data) => onReject(data));
+        const failSub = onFailed ? callEventEmitter.addListener('onCallFailed', (data) => onFailed(data)) : null;
+
+        return () => {
+            acceptSub.remove();
+            rejectSub.remove();
+            if (failSub) failSub.remove();
+        };
+    }
+};

package/ios/CallModule.h

@@ -0,0 +1,7 @@
+#import <CallKit/CallKit.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface CallModule : RCTEventEmitter <RCTBridgeModule, CXProviderDelegate>
+@property(nonatomic, strong) CXProvider *provider;
+@end

package/ios/CallModule.m

@@ -0,0 +1,95 @@
+#import "CallModule.h"
+
+@implementation CallModule
+
+RCT_EXPORT_MODULE();
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[ @"onCallAccepted", @"onCallRejected", @"onCallFailed" ];
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        CXProviderConfiguration *config = [[CXProviderConfiguration alloc] initWithLocalizedName:@"Raiidr"];
+#pragma clang diagnostic pop
+
+        config.supportsVideo = YES;
+        config.maximumCallGroups = 1;
+        config.maximumCallsPerCallGroup = 1;
+        config.supportedHandleTypes = [NSSet setWithObject:@(CXHandleTypeGeneric)];
+        config.includesCallsInRecents = NO; // <-- prevent log
+
+        // If you had a custom file like "Ringtone.aif" in your project,
+        // you would set it here:
+        // config.ringtoneSound = @"Ringtone.aif";
+
+        self.provider = [[CXProvider alloc] initWithConfiguration:config];
+        [self.provider setDelegate:self queue:nil];
+    }
+    return self;
+}
+
+// Updated with showRing (BOOL)
+RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
+                  number:(NSString *)number
+                  name:(NSString *)name
+                  hasVideo:(BOOL)hasVideo
+                  showRing:(BOOL)showRing
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
+    if (!uuid) {
+        reject(@"INVALID_UUID", @"The provided UUID string is invalid", nil);
+        return;
+    }
+
+    CXCallUpdate *update = [[CXCallUpdate alloc] init];
+    update.remoteHandle = [[CXHandle alloc] initWithType:CXHandleTypeGeneric value:name];
+    update.hasVideo = hasVideo;
+    
+    // Note: CallKit handles ringing based on the CXProviderConfiguration.
+    // iOS doesn't allow toggling 'ring' per-call via reportNewIncomingCall.
+    // However, including it here ensures your JS bridge call matches.
+
+    [self.provider reportNewIncomingCallWithUUID:uuid
+                                          update:update
+                                      completion:^(NSError *_Nullable error) {
+        if (error) {
+            reject(@"CALL_ERROR", error.localizedDescription, error);
+        } else {
+            resolve(@YES);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString) {
+    NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
+    if (uuid) {
+        [self.provider reportCallWithUUID:uuid
+                              endedAtDate:[NSDate date]
+                                   reason:CXCallEndedReasonRemoteEnded];
+
+    }
+}
+
+// MARK: - CXProviderDelegate
+
+- (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {
+    [action fulfill];
+    [self sendEventWithName:@"onCallAccepted"
+                       body:@{@"callUUID" : [action.callUUID.UUIDString lowercaseString]}];
+}
+
+- (void)provider:(CXProvider *)provider performEndCallAction:(CXEndCallAction *)action {
+    [action fulfill];
+    [self sendEventWithName:@"onCallRejected"
+                       body:@{@"callUUID" : [action.callUUID.UUIDString lowercaseString]}];
+}
+
+- (void)providerDidReset:(CXProvider *)provider { }
+
+@end

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "rns-nativecall",
+    "version": "0.0.1",
+    "description": "Raiidr nativecall component with native Android/iOS for handling native call ui, when app is not open or open.",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "react-native": "index.js",
+    "scripts": {
+        "p": "npm publish --access public"
+    },
+    "expo": {
+        "plugins": [
+            "./app.plugin.js"
+        ]
+    },
+    "keywords": [
+        "react-native",
+        "nativecall",
+        "call",
+        "native",
+        "call keep",
+        "android",
+        "expo",
+        "incognito",
+        "dialog suppression",
+        "keyboard stability",
+        "lifecycle events"
+    ],
+    "files": [
+        "android",
+        "ios",
+        "app.plugin.js",
+        "index.d.ts",
+        "index.js",
+        "package.json",
+        "react-native.config",
+        "README.md",
+        "rns-nativecall.podspec",
+        "withRaiidrVoip"
+    ],
+    "peerDependencies": {
+        "react-native": "*",
+        "expo": "*"
+    },
+    "dependencies": {
+        "@expo/config-plugins": "~10.1.1"
+    }
+}

package/rns-nativecall.podspec

@@ -0,0 +1,18 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = package["name"]
+  s.version      = package["version"]
+  s.summary      = package["description"] || "Custom native call for React Native"
+  s.license      = package["license"] || "MIT"
+  s.author       = package["author"] || "Unknown"
+  s.homepage     = package["homepage"] || "https://github.com/your/repo"
+  s.source       = { :git => "https://github.com/raiidr/rns-nativecall.git", :tag => "#{s.version}"  }
+
+  s.platforms    = { :ios => "11.0" }
+  s.source_files  = "ios/**/*.{h,m}"
+
+  s.dependency "React-Core"
+end