@nativetalkcommunications/react-native-call-sdk 0.1.0

package/android/src/main/java/io/nativetalk/callsdk/NativetalkCallScreeningService.kt

@@ -0,0 +1,105 @@
+package io.nativetalk.callsdk
+
+import android.os.Build
+import android.telecom.Call
+import android.telecom.CallScreeningService
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+
+/**
+ * Optional call-screening service.
+ *
+ * Apps that want to be notified about every inbound/outbound device call
+ * (e.g. to decide whether to suppress a competing VoIP call) must set this
+ * package as the user's call-screener via
+ * `TelecomManager.requestRoleOrSomething(ROLE_CALL_SCREENING)`. Otherwise
+ * the OS never invokes this class — it's dormant by default.
+ *
+ * Counterpart: [TelephonyMonitor] watches READ_PHONE_STATE-style call state.
+ * This service receives richer per-call metadata BEFORE the call rings.
+ */
+class NativetalkCallScreeningService : CallScreeningService() {
+    companion object {
+        private const val TAG = "NativetalkCallSdk.Screening"
+    }
+
+    override fun onScreenCall(details: Call.Details) {
+        try {
+            val number = extractPhoneNumber(details)
+            val isIncoming = details.callDirection == Call.Details.DIRECTION_INCOMING
+            val ts = System.currentTimeMillis()
+            // Optional contact lookup — only if we got a number AND the host
+            // app has granted READ_CONTACTS. Silently skipped otherwise.
+            val contact = if (number.isNotEmpty()) TelephonyMonitor.tryLookupContact(number) else null
+
+            val payload = Arguments.createMap().apply {
+                putString("direction", if (isIncoming) "incoming" else "outgoing")
+                putString("number", number)
+                putString("callerName", details.callerDisplayName ?: "")
+                putDouble("timestamp", ts.toDouble())
+                putInt("presentation", details.callerDisplayNamePresentation)
+                if (contact != null) putMap("contact", contact)
+            }
+            TelephonyMonitor.emitToReact("TMPhoneCallInfo", payload)
+
+            // We're an OBSERVER, not a blocker. All four flags false → let
+            // the call proceed normally, show in the log, fire notifications.
+            // Apps that want to actually block calls should use a separate
+            // dialler-style screener; this SDK only surfaces metadata.
+            respondToCall(
+                details,
+                CallResponse.Builder()
+                    .setDisallowCall(false)
+                    .setRejectCall(false)
+                    .setSkipCallLog(false)
+                    .setSkipNotification(false)
+                    .build()
+            )
+        } catch (t: Throwable) {
+            Log.e(TAG, "onScreenCall failed", t)
+            // CRITICAL: must respond even on failure. Skipping respondToCall
+            // hangs the system dialler — the user would see a perpetually
+            // "connecting" call. Better to swallow the error and let the
+            // call proceed.
+            respondToCall(
+                details,
+                CallResponse.Builder()
+                    .setDisallowCall(false)
+                    .setRejectCall(false)
+                    .build()
+            )
+        }
+    }
+
+    /**
+     * Three fallback strategies for getting the phone number, in order of
+     * reliability. OEM Telecom implementations are inconsistent — some
+     * populate `handle`, some only `callerDisplayName`, some only `extras`.
+     */
+    private fun extractPhoneNumber(details: Call.Details): String {
+        // 1. The standard place: `handle` is a tel: URI; we want its body.
+        val handle = details.handle
+        if (handle != null) {
+            val number = handle.schemeSpecificPart
+            if (!number.isNullOrEmpty()) return number
+        }
+        // 2. Some carriers shove the number into the display-name field.
+        //    Only trust it if it's at least 10 digits — shorter strings are
+        //    probably a real name like "John" with stray digits.
+        details.callerDisplayName?.let { dn ->
+            val cleaned = dn.replace(Regex("[^0-9+]"), "")
+            if (cleaned.length >= 10) return cleaned
+        }
+        // 3. Last resort: vendor-specific extras. The three keys below cover
+        //    Samsung, Xiaomi, and a few Asian carriers respectively.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            details.extras?.let { extras ->
+                val extraNumber = extras.getString("android.telecom.extra.CALL_SUBJECT")
+                    ?: extras.getString("call_number")
+                    ?: extras.getString("phone_number")
+                if (!extraNumber.isNullOrEmpty()) return extraNumber
+            }
+        }
+        return ""
+    }
+}

package/android/src/main/java/io/nativetalk/callsdk/NativetalkCallSdkModule.kt

@@ -0,0 +1,205 @@
+package io.nativetalk.callsdk
+
+import android.content.Intent
+import android.media.AudioManager
+import android.media.ToneGenerator
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import org.linphone.core.Core
+import org.linphone.core.ProxyConfig
+import org.linphone.core.RegistrationState
+
+/**
+ * Native bridge exposed to JavaScript as `NativeModules.NativetalkCallSdk`.
+ *
+ * Intentionally thin: every @ReactMethod is a 1-line delegate to
+ * [CoreManager] or another singleton. Keeping the engine in [CoreManager]
+ * (not here) means push-driven background services can drive calls before
+ * React has even mounted.
+ *
+ * The string `"NativetalkCallSdk"` is the contract with JS — must exactly
+ * match `NativeModules.NativetalkCallSdk` and `@objc(NativetalkCallSdk)` on
+ * iOS. Renaming this breaks the bridge silently.
+ */
+class NativetalkCallSdkModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "NativetalkCallSdk"
+        private const val TAG = "NativetalkCallSdk"
+    }
+
+    // Lazily-created tone generator. Allocating a ToneGenerator pre-warms
+    // the audio HAL (~50ms hit), so we defer until the first key press.
+    private var dtmfTone: ToneGenerator? = null
+
+    override fun getName(): String = NAME
+
+    // === Lifecycle ===
+
+    @ReactMethod
+    fun init(cfg: ReadableMap?, promise: Promise) {
+        try {
+            CoreManager.attachReact(reactContext)
+            TelephonyMonitor.attachReact(reactContext)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("INIT_FAILED", e)
+        }
+    }
+
+    @ReactMethod
+    fun startNativeServices() {
+        CoreManager.ensureStarted(reactContext)
+        BackgroundService.startService(reactContext)
+    }
+
+    @ReactMethod
+    fun stopNativeServices(logout: Boolean) {
+        if (logout) BackgroundService.shouldRestart = false
+        reactContext.stopService(Intent(reactContext, CallService::class.java))
+        BackgroundService.stopService(reactContext)
+        CoreManager.stop()
+    }
+
+    // === Registration ===
+
+    @ReactMethod
+    fun register(acc: ReadableMap) {
+        CoreManager.ensureStarted(reactContext)
+        CoreManager.register(
+            acc.getString("username") ?: "",
+            acc.getString("password") ?: "",
+            acc.getString("domain") ?: "",
+            acc.getString("transport") ?: "tcp"
+        )
+    }
+
+    @ReactMethod
+    fun refreshRegisters() {
+        CoreManager.refreshRegisters()
+    }
+
+    @ReactMethod
+    fun setRegisterEnabled(on: Boolean) {
+        CoreManager.setRegisterEnabled(on)
+    }
+
+    @ReactMethod
+    fun getRegistrationStatus(promise: Promise) {
+        try {
+            val core: Core? = CoreManager.core()
+            val pc: ProxyConfig? = core?.defaultProxyConfig
+            val addr = pc?.identityAddress
+
+            val diag: String = try {
+                pc?.errorInfo?.phrase ?: pc?.errorInfo?.toString() ?: ""
+            } catch (_: Throwable) { "" }
+
+            val map = Arguments.createMap().apply {
+                putString("state", regStateToString(pc?.state))
+                putString("message", diag)
+                putString("username", addr?.username ?: "")
+                putString("domain", addr?.domain ?: "")
+                putString("displayName", addr?.displayName ?: "")
+            }
+            promise.resolve(map)
+        } catch (e: Throwable) {
+            promise.reject("E_STATUS", "Failed to read registration status", e)
+        }
+    }
+
+    // === Call control ===
+
+    @ReactMethod fun call(sipUri: String) = CoreManager.call(sipUri)
+    @ReactMethod fun answer() = CoreManager.answer()
+    @ReactMethod fun decline(reason: String?) = CoreManager.decline()
+    @ReactMethod fun end() = CoreManager.end()
+    @ReactMethod fun hangup() = end()
+    @ReactMethod fun mute(on: Boolean) = CoreManager.mute(on)
+    @ReactMethod fun speaker(on: Boolean) = CoreManager.speaker(on)
+    @ReactMethod fun sendDtmf(d: String) = CoreManager.sendDtmf(d)
+    @ReactMethod fun hold() = CoreManager.hold()
+    @ReactMethod fun resume() = CoreManager.resume()
+
+    // === Call logs ===
+
+    @ReactMethod
+    fun getCallLogs(promise: Promise) {
+        try {
+            promise.resolve(CoreManager.getCallLogs())
+        } catch (e: Exception) {
+            Log.e(TAG, "getCallLogs failed", e)
+            promise.reject("GET_CALL_LOGS_FAILED", e.message, e)
+        }
+    }
+
+    // === Misc ===
+
+    /**
+     * Plays a local DTMF UI tone — for tactile feedback when the user taps
+     * the dial-pad. Does NOT send anything over an active call (that's
+     * `sendDtmf`).
+     *
+     * Unlike the iOS side (which synthesises tones manually via
+     * AVAudioEngine), Android's stock `ToneGenerator` already routes
+     * correctly through the voice-call audio stream, including BT headsets.
+     * The volume parameter (60/100) is moderate — full volume sounds
+     * harsh when held to the ear.
+     */
+    @ReactMethod
+    fun playKeyTone(d: String) {
+        if (dtmfTone == null) {
+            dtmfTone = ToneGenerator(AudioManager.STREAM_VOICE_CALL, 60)
+        }
+        // Each key has a dedicated constant (TONE_DTMF_0..9, _S for *, _P
+        // for #). Anything else falls back to a generic beep so a typo
+        // produces SOMETHING audible rather than silence.
+        val tone = when (d) {
+            "0" -> ToneGenerator.TONE_DTMF_0
+            "1" -> ToneGenerator.TONE_DTMF_1
+            "2" -> ToneGenerator.TONE_DTMF_2
+            "3" -> ToneGenerator.TONE_DTMF_3
+            "4" -> ToneGenerator.TONE_DTMF_4
+            "5" -> ToneGenerator.TONE_DTMF_5
+            "6" -> ToneGenerator.TONE_DTMF_6
+            "7" -> ToneGenerator.TONE_DTMF_7
+            "8" -> ToneGenerator.TONE_DTMF_8
+            "9" -> ToneGenerator.TONE_DTMF_9
+            "*" -> ToneGenerator.TONE_DTMF_S
+            "#" -> ToneGenerator.TONE_DTMF_P
+            else -> ToneGenerator.TONE_PROP_BEEP
+        }
+        // 120ms — matches the iOS DTMF feedback duration and the stock
+        // dialer's feel. Anything longer feels laggy on rapid tapping.
+        dtmfTone?.startTone(tone, 120)
+    }
+
+    // RN's NativeEventEmitter calls addListener/removeListeners when JS
+    // subscribes/unsubscribes. Required so RN doesn't warn at runtime; we
+    // don't track count because we use RCTDeviceEventEmitter directly from
+    // [CoreManager], which keeps events flowing regardless of subscriber
+    // count.
+    @ReactMethod fun addListener(event: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
+    // Called when RN tears down the bridge (app close, hot reload). We
+    // null-out the React reference so [CoreManager.emit] becomes a no-op
+    // — but the underlying Linphone core keeps running, ready for a fresh
+    // React context to attach later.
+    override fun onCatalystInstanceDestroy() {
+        TelephonyMonitor.detachReact()
+        CoreManager.detachReact()
+        super.onCatalystInstanceDestroy()
+    }
+
+    private fun regStateToString(s: RegistrationState?): String = when (s) {
+        RegistrationState.None -> "none"
+        RegistrationState.Progress -> "progress"
+        RegistrationState.Ok -> "ok"
+        RegistrationState.Cleared -> "cleared"
+        RegistrationState.Failed -> "failed"
+        else -> "unknown"
+    }
+}

package/android/src/main/java/io/nativetalk/callsdk/NativetalkCallSdkPackage.kt

@@ -0,0 +1,18 @@
+package io.nativetalk.callsdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package entry. Registered automatically by autolinking — no
+ * manual changes to `MainApplication` needed in apps using React Native 0.71+.
+ */
+class NativetalkCallSdkPackage : ReactPackage {
+    override fun createNativeModules(rc: ReactApplicationContext): List<NativeModule> =
+        listOf(NativetalkCallSdkModule(rc))
+
+    override fun createViewManagers(rc: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/android/src/main/java/io/nativetalk/callsdk/TelephonyMonitor.kt

@@ -0,0 +1,229 @@
+package io.nativetalk.callsdk
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.ContactsContract
+import android.telephony.PhoneStateListener
+import android.telephony.TelephonyCallback
+import android.telephony.TelephonyManager
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Observes the device's native GSM/cellular call state and surfaces the
+ * transitions to JS as `TMPhoneCallState` and `TMPhoneCallInfo` events.
+ *
+ * Why this matters: a VoIP app needs to know when the user is on a regular
+ * phone call so it can decline the SIP call gracefully instead of letting
+ * Linphone fight the cellular audio for the mic.
+ *
+ * No iOS counterpart — Apple doesn't expose cellular call state to apps;
+ * CallKit handles the coexistence automatically.
+ *
+ * Permission model: requires READ_PHONE_STATE for telephony updates and
+ * READ_CONTACTS for caller-name lookups. Both are host-app responsibility
+ * — if not granted, this monitor silently no-ops.
+ */
+object TelephonyMonitor {
+    private const val TAG = "NativetalkCallSdk.Telephony"
+
+    private var tm: TelephonyManager? = null
+    private var rc: ReactApplicationContext? = null
+    private var appCtx: Context? = null
+
+    // Two listener fields because Android 12+ deprecated PhoneStateListener
+    // in favour of TelephonyCallback. We use whichever is available at
+    // runtime (see [start]).
+    private var cb: TelephonyCallback? = null
+    private var oldListener: PhoneStateListener? = null
+
+    // Cached info about the current call. We stash these here because the
+    // direction and number can arrive in separate callbacks (RINGING then
+    // OFFHOOK) — we have to remember the earlier value to emit a complete
+    // event when the later one fires.
+    private var currentCallState = TelephonyManager.CALL_STATE_IDLE
+    private var pendingCallNumber: String? = null
+    private var pendingCallDirection: String? = null
+
+    private val handler = Handler(Looper.getMainLooper())
+
+    fun attachReact(reactContext: ReactApplicationContext) {
+        rc = reactContext
+    }
+
+    fun detachReact() {
+        rc = null
+    }
+
+    fun start(context: Context) {
+        try {
+            appCtx = context.applicationContext
+            tm = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
+
+            // Fail soft: without READ_PHONE_STATE the OS silently delivers
+            // no events, so registering listeners would just waste handles.
+            if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE)
+                != PackageManager.PERMISSION_GRANTED
+            ) {
+                Log.w(TAG, "READ_PHONE_STATE not granted; telephony observer inactive")
+                return
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                // API 31+: TelephonyCallback. Note that the modern API
+                // does NOT pass the phone number to onCallStateChanged
+                // (privacy hardening) — we fill it in from CallScreeningService
+                // when available.
+                val callback = object : TelephonyCallback(), TelephonyCallback.CallStateListener {
+                    override fun onCallStateChanged(state: Int) {
+                        handleCallStateChange(state, null)
+                    }
+                }
+                cb = callback
+                tm?.registerTelephonyCallback(context.mainExecutor, callback)
+            } else {
+                // Legacy PhoneStateListener (< API 31). Deprecated but still
+                // works and DOES include the phone number directly.
+                @Suppress("DEPRECATION")
+                val listener = object : PhoneStateListener() {
+                    override fun onCallStateChanged(state: Int, phoneNumber: String?) {
+                        handleCallStateChange(state, phoneNumber)
+                    }
+                }
+                oldListener = listener
+                @Suppress("DEPRECATION")
+                tm?.listen(listener, PhoneStateListener.LISTEN_CALL_STATE)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to start telephony monitoring", e)
+        }
+    }
+
+    fun stop() {
+        try {
+            handler.removeCallbacksAndMessages(null)
+            tm?.let { mgr ->
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    cb?.let { mgr.unregisterTelephonyCallback(it) }
+                    cb = null
+                } else {
+                    @Suppress("DEPRECATION")
+                    oldListener?.let { mgr.listen(it, PhoneStateListener.LISTEN_NONE) }
+                    oldListener = null
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error stopping telephony monitoring", e)
+        }
+    }
+
+    fun setPendingCallInfo(number: String?, direction: String) {
+        pendingCallNumber = number
+        pendingCallDirection = direction
+    }
+
+    private fun handleCallStateChange(newState: Int, phoneNumber: String?) {
+        val previous = currentCallState
+        currentCallState = newState
+
+        if (!phoneNumber.isNullOrEmpty() && phoneNumber != pendingCallNumber) {
+            pendingCallNumber = phoneNumber
+        }
+
+        when (newState) {
+            TelephonyManager.CALL_STATE_OFFHOOK -> {
+                // IDLE → OFFHOOK with no preceding RINGING means we just
+                // placed an outgoing call. RINGING → OFFHOOK would mean we
+                // answered an incoming one, and pendingCallDirection was
+                // already set by the RINGING handler.
+                if (previous == TelephonyManager.CALL_STATE_IDLE) {
+                    pendingCallDirection = "outgoing"
+                }
+            }
+            TelephonyManager.CALL_STATE_IDLE -> {
+                // Clear cached call info AFTER a 2s delay so any late-arriving
+                // CallScreeningService callback (which can lag the state
+                // change by 1–2s on some OEMs) still has access to it.
+                handler.postDelayed({
+                    pendingCallNumber = null
+                    pendingCallDirection = null
+                }, 2000)
+            }
+        }
+        emitState(newState)
+    }
+
+    fun emitToReact(event: String, payload: WritableMap) {
+        try {
+            val ctx = rc
+            if (ctx == null || !ctx.hasActiveCatalystInstance()) return
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit(event, payload)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit '$event'", e)
+        }
+    }
+
+    fun tryLookupContact(number: String): WritableMap? {
+        if (number.isBlank()) return null
+        val ctx = appCtx ?: return null
+        if (ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_CONTACTS)
+            != PackageManager.PERMISSION_GRANTED
+        ) return null
+
+        try {
+            val uri = Uri.withAppendedPath(
+                ContactsContract.PhoneLookup.CONTENT_FILTER_URI,
+                Uri.encode(number)
+            )
+            val cols = arrayOf(
+                ContactsContract.PhoneLookup.DISPLAY_NAME,
+                ContactsContract.PhoneLookup.PHOTO_THUMBNAIL_URI
+            )
+            ctx.contentResolver.query(uri, cols, null, null, null)?.use { cursor ->
+                if (cursor.moveToFirst()) {
+                    return Arguments.createMap().apply {
+                        putString("name", cursor.getString(0))
+                        putString("photo", cursor.getString(1))
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Contact lookup failed for $number", e)
+        }
+        return null
+    }
+
+    private fun emitState(state: Int) {
+        val stateName = stateName(state)
+        try {
+            val ctx = rc
+            if (ctx == null || !ctx.hasActiveCatalystInstance()) return
+            val map = Arguments.createMap().apply {
+                putString("state", stateName)
+                putInt("code", state)
+                putDouble("timestamp", System.currentTimeMillis().toDouble())
+            }
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("TMPhoneCallState", map)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit telephony state", e)
+        }
+    }
+
+    private fun stateName(state: Int) = when (state) {
+        TelephonyManager.CALL_STATE_RINGING -> "ringing"
+        TelephonyManager.CALL_STATE_OFFHOOK -> "offhook"
+        TelephonyManager.CALL_STATE_IDLE -> "idle"
+        else -> "unknown_$state"
+    }
+}

package/android/src/main/java/io/nativetalk/callsdk/Utils.kt

@@ -0,0 +1,42 @@
+package io.nativetalk.callsdk
+
+import androidx.annotation.AnyThread
+import androidx.annotation.WorkerThread
+import org.linphone.core.Address
+import org.linphone.core.Call
+
+/** Internal helpers — not exposed to JS. */
+object Utils {
+    @WorkerThread
+    fun displayNameFor(address: Address?): String {
+        if (address == null) return "[null]"
+        val dn = address.displayName
+        return if (dn.isNullOrEmpty()) address.username ?: address.asString() else dn
+    }
+
+    @AnyThread
+    fun isCallIncoming(state: Call.State): Boolean = when (state) {
+        Call.State.IncomingReceived, Call.State.IncomingEarlyMedia -> true
+        else -> false
+    }
+
+    @AnyThread
+    fun isCallOutgoing(state: Call.State, considerEarlyMedia: Boolean = true): Boolean = when (state) {
+        Call.State.OutgoingInit, Call.State.OutgoingProgress, Call.State.OutgoingRinging -> true
+        Call.State.OutgoingEarlyMedia -> considerEarlyMedia
+        else -> false
+    }
+
+    @AnyThread
+    fun isCallPaused(state: Call.State): Boolean = when (state) {
+        Call.State.Pausing, Call.State.Paused, Call.State.PausedByRemote, Call.State.Resuming -> true
+        else -> false
+    }
+
+    @AnyThread
+    fun isCallEnding(state: Call.State, considerReleasedAsEnding: Boolean = false): Boolean = when (state) {
+        Call.State.End, Call.State.Error -> true
+        Call.State.Released -> considerReleasedAsEnding
+        else -> false
+    }
+}

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

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="24dp"
+  android:height="24dp"
+  android:viewportWidth="24"
+  android:viewportHeight="24">
+  <path
+    android:fillColor="#FFFFFFFF"
+    android:pathData="M6.62,10.79c1.44,2.83 3.76,5.15 6.59,6.59l2.2,-2.2c0.27,-0.27 0.67,-0.36 1.02,-0.24 1.12,0.37 2.33,0.57 3.57,0.57 0.55,0 1,0.45 1,1V20c0,0.55 -0.45,1 -1,1 -9.39,0 -17,-7.61 -17,-17 0,-0.55 0.45,-1 1,-1h3.5c0.55,0 1,0.45 1,1 0,1.24 0.2,2.45 0.57,3.57 0.11,0.35 0.03,0.74 -0.25,1.02l-2.2,2.2z"/>
+</vector>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,9 @@
+<resources>
+    <string name="nativetalk_call_sdk_app_name" translatable="false">App</string>
+    <string name="nativetalk_call_sdk_notif_channel_call_id" translatable="false">nativetalk_calls</string>
+    <string name="nativetalk_call_sdk_notif_channel_call_name">Calls</string>
+    <string name="nativetalk_call_sdk_notif_channel_background_id" translatable="false">nativetalk_background</string>
+    <string name="nativetalk_call_sdk_notif_channel_background_name">Call service</string>
+    <string name="nativetalk_call_sdk_ready_title">Ready to receive calls</string>
+    <string name="nativetalk_call_sdk_ready_body">Keeping the connection alive</string>
+</resources>

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build/index.js');

package/ios/NativetalkCallSdk-Bridging-Header.h

@@ -0,0 +1,4 @@
+// Empty bridging header. Required by Swift compilation when the SDK is built
+// as a static library. The host app's bridging header is unaffected.
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>