@nativetalkcommunications/react-native-call-sdk 0.1.0

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

@@ -0,0 +1,149 @@
+package io.nativetalk.callsdk
+
+import android.app.AlarmManager
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.IBinder
+import android.os.PowerManager
+import android.os.SystemClock
+import android.util.Log
+import androidx.core.app.NotificationCompat
+
+/**
+ * Long-running foreground service that keeps the SIP registration warm even
+ * when the user has backgrounded the app. Hosts a wake lock and (re)starts
+ * [CallService] if the OS kills it.
+ *
+ * Lifecycle: `startService()` → `onCreate` (wake lock + TelephonyMonitor) →
+ * `onStartCommand` (foreground notification + spawn CallService). On
+ * task-removal we schedule an alarm to relaunch ourselves a second later.
+ */
+class BackgroundService : Service() {
+
+    companion object {
+        private const val NOTIFICATION_ID = 1000
+        private const val CHANNEL_ID = "nativetalk_background"
+        private const val TAG = "NativetalkCallSdk.BgService"
+
+        // Set to `false` by the JS bridge during explicit logout so that
+        // onTaskRemoved doesn't immediately respawn us. @Volatile because
+        // the flag is read/written from different threads (RN bridge thread
+        // vs main thread handling task-removal).
+        @Volatile var shouldRestart = true
+
+        fun startService(context: Context) {
+            val intent = Intent(context, BackgroundService::class.java)
+            // `startForegroundService` (not `startService`) is required on
+            // Android 8+ — the OS gives us a 5-second window to call
+            // `startForeground` or it kills us with a SecurityException.
+            context.startForegroundService(intent)
+        }
+
+        fun stopService(context: Context) {
+            val intent = Intent(context, BackgroundService::class.java)
+            context.stopService(intent)
+        }
+    }
+
+    private var wakeLock: PowerManager.WakeLock? = null
+    private var connectivityManager: ConnectivityManager? = null
+
+    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            Log.d(TAG, "Network available — triggering re-registration")
+            CoreManager.refreshRegisters()
+        }
+        override fun onLost(network: Network) {
+            Log.d(TAG, "Network lost")
+            CoreManager.setNetworkReachable(false)
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        createChannel()
+        val pm = getSystemService(Context.POWER_SERVICE) as PowerManager
+        wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "NativetalkCallSdk::BackgroundService")
+        // 10-minute timeout: Android's StrictMode warns if a wake lock has
+        // no timeout, and 10min is long enough to register & answer a call
+        // but short enough that a buggy service can't drain the battery.
+        wakeLock?.acquire(10 * 60 * 1000L)
+
+        TelephonyMonitor.start(applicationContext)
+
+        connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val request = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+        connectivityManager?.registerNetworkCallback(request, networkCallback)
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        // Must call startForeground within ~5s of startForegroundService —
+        // do it first thing here.
+        startForeground(NOTIFICATION_ID, buildNotification())
+        // CallService owns the per-call notification; this service owns
+        // the "always-on" registration notification.
+        applicationContext.startService(Intent(applicationContext, CallService::class.java))
+        // START_STICKY: if the OS kills us under memory pressure, restart
+        // us with a null intent. That's what we want for a keep-alive.
+        return START_STICKY
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        // Fires when the user swipes the app from recents. The OS often
+        // kills our service shortly after, so we set a 1-second alarm to
+        // relaunch ourselves. The alarm survives even if our process dies.
+        if (shouldRestart) {
+            val restart = Intent(applicationContext, BackgroundService::class.java)
+            val pending = PendingIntent.getService(
+                this,
+                1,
+                restart,
+                PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE
+            )
+            val alarm = getSystemService(Context.ALARM_SERVICE) as AlarmManager
+            alarm.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + 1000, pending)
+        }
+        super.onTaskRemoved(rootIntent)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        runCatching { connectivityManager?.unregisterNetworkCallback(networkCallback) }
+        wakeLock?.release()
+        TelephonyMonitor.stop()
+    }
+
+    private fun createChannel() {
+        val ch = NotificationChannel(
+            CHANNEL_ID,
+            getString(R.string.nativetalk_call_sdk_notif_channel_background_name),
+            NotificationManager.IMPORTANCE_LOW
+        ).apply {
+            description = getString(R.string.nativetalk_call_sdk_ready_body)
+            setShowBadge(false)
+        }
+        val manager = getSystemService(NotificationManager::class.java)
+        manager.createNotificationChannel(ch)
+    }
+
+    private fun buildNotification() = NotificationCompat.Builder(this, CHANNEL_ID)
+        .setContentTitle(getString(R.string.nativetalk_call_sdk_ready_title))
+        .setContentText(getString(R.string.nativetalk_call_sdk_ready_body))
+        .setSmallIcon(R.drawable.ic_nativetalk_call)
+        .setOngoing(true)
+        .setCategory(NotificationCompat.CATEGORY_SERVICE)
+        .setPriority(NotificationCompat.PRIORITY_LOW)
+        .build()
+}

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

@@ -0,0 +1,24 @@
+package io.nativetalk.callsdk
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+
+/**
+ * Receives Answer / Decline button taps on the heads-up call notification and
+ * forwards them to [CoreManager].
+ */
+class CallActionReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+        Log.d(TAG, "Received action: ${intent?.action}")
+        when (intent?.action) {
+            CoreManager.ACTION_ANSWER_CALL -> CoreManager.answer()
+            CoreManager.ACTION_DECLINE_CALL -> CoreManager.decline()
+        }
+    }
+
+    private companion object {
+        const val TAG = "NativetalkCallSdk.Receiver"
+    }
+}

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

@@ -0,0 +1,45 @@
+package io.nativetalk.callsdk
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import android.util.Log
+
+/**
+ * Foreground service that owns the call notification.
+ *
+ * Started by [BackgroundService] and by [NativetalkCallSdkModule.startNativeServices].
+ * The actual lifecycle of the Linphone core lives in [CoreManager]; this
+ * service is mostly a holder for the foreground-notification slot.
+ */
+class CallService : Service() {
+
+    override fun onCreate() {
+        super.onCreate()
+        Log.i(TAG, "onCreate")
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Log.i(TAG, "onStartCommand")
+        CoreManager.onCallServiceStarted(this)
+        return super.onStartCommand(intent, flags, startId)
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        if (BackgroundService.shouldRestart) {
+            startService(Intent(applicationContext, CallService::class.java))
+        }
+        super.onTaskRemoved(rootIntent)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        Log.i(TAG, "onDestroy")
+    }
+
+    private companion object {
+        const val TAG = "NativetalkCallSdk.CallService"
+    }
+}

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

@@ -0,0 +1,96 @@
+package io.nativetalk.callsdk
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Notification
+import android.app.Service
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+
+/**
+ * Thin shims over `Service.startForeground(…)` and the runtime
+ * POST_NOTIFICATIONS check. Required because Android 14 (API 34) made the
+ * foreground-service-type parameter MANDATORY for `phoneCall` / `microphone`
+ * services — calling the 2-arg overload on API 34 throws SecurityException,
+ * while the 3-arg overload doesn't exist on older versions.
+ *
+ * Centralising the version dispatch here keeps [CoreManager] free of
+ * `Build.VERSION.SDK_INT` checks.
+ */
+@SuppressLint("NewApi")
+class Compatibility {
+    companion object {
+        private const val TAG = "NativetalkCallSdk.Compat"
+
+        // Type bitmask values, copied here so callers don't need to depend
+        // on android.content.pm.ServiceInfo (which would force API-30+).
+        //   4   = ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
+        //   128 = ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+        // OR them together when a call needs both mic + phoneCall (active call).
+        const val FOREGROUND_SERVICE_TYPE_PHONE_CALL = 4
+        const val FOREGROUND_SERVICE_TYPE_MICROPHONE = 128
+
+        // Dispatch to the right startForeground overload by API level.
+        // `UPSIDE_DOWN_CAKE` is the Build.VERSION_CODES constant for API 34.
+        fun startServiceForeground(
+            service: Service,
+            id: Int,
+            notification: Notification,
+            foregroundServiceType: Int
+        ) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                Api34.startServiceForeground(service, id, notification, foregroundServiceType)
+            } else {
+                Legacy.startServiceForeground(service, id, notification)
+            }
+        }
+
+        // POST_NOTIFICATIONS only exists as a runtime permission on Android
+        // 13+ (TIRAMISU). On older versions, having the manifest entry is
+        // enough — return true so callers don't need their own version check.
+        fun isPostNotificationsPermissionGranted(context: Context): Boolean {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                return context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+            }
+            return true
+        }
+    }
+}
+
+// API 34+ path. The `@RequiresApi` annotation lets the IDE catch any caller
+// that bypasses [Compatibility.startServiceForeground] and reaches this
+// directly on an older device.
+@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+private object Api34 {
+    fun startServiceForeground(
+        service: Service,
+        id: Int,
+        notification: Notification,
+        foregroundServiceType: Int
+    ) {
+        // Wrapped in try/catch because even with the right type mask the
+        // OS can still reject the foreground transition (e.g. user disabled
+        // POST_NOTIFICATIONS, or background-start restrictions). We log
+        // rather than crash because the call itself usually still works —
+        // just without a notification.
+        try {
+            service.startForeground(id, notification, foregroundServiceType)
+        } catch (e: Exception) {
+            Log.e("NativetalkCallSdk.Compat", "startForeground (API34) failed", e)
+        }
+    }
+}
+
+// Pre-API-34 path: the 2-arg overload. No type mask needed.
+private object Legacy {
+    fun startServiceForeground(service: Service, id: Int, notification: Notification) {
+        try {
+            service.startForeground(id, notification)
+        } catch (e: Exception) {
+            Log.e("NativetalkCallSdk.Compat", "startForeground (legacy) failed", e)
+        }
+    }
+}