react-native-telecom 0.0.0-stage → 0.1.1

package/android/src/main/java/com/telecom/CallSessionManager.kt

@@ -0,0 +1,486 @@
+package com.telecom
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.AudioManager
+import android.media.ToneGenerator
+import android.net.Uri
+import android.os.Build
+import android.telecom.DisconnectCause
+import androidx.core.content.ContextCompat
+import androidx.core.telecom.CallAttributesCompat
+import androidx.core.telecom.CallsManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+internal class CallSessionManager(
+  private val context: Context,
+  private var emit: (eventName: String, params: WritableMap) -> Unit,
+) {
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+  private val callsManager = CallsManager(context)
+  private val sessions = ConcurrentHashMap<String, CallSession>()
+  private val starting = ConcurrentHashMap.newKeySet<String>()
+  private val pendingAutoAnswer = ConcurrentHashMap.newKeySet<String>()
+  private var registered = false
+  private val audioRouter = TelecomAudioRouter(context) { name, params -> emit(name, params) }
+
+  init {
+    instance = this
+  }
+
+  fun rebindEmitter(next: (eventName: String, params: WritableMap) -> Unit) {
+    emit = next
+  }
+
+  fun setup(supportsVideo: Boolean, ui: TelecomUiConfig? = null): Boolean {
+    if (ui != null) {
+      TelecomUiConfig.current = ui
+    }
+    ensureManageOwnCallsPermission()
+
+    var capabilities = CallsManager.CAPABILITY_BASELINE
+    if (supportsVideo) {
+      capabilities = capabilities or CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING
+    }
+
+    callsManager.registerAppWithTelecom(capabilities)
+    registered = true
+    return true
+  }
+
+  fun displayIncomingCall(
+    uuid: String,
+    handle: String,
+    callerName: String,
+    hasVideo: Boolean,
+    autoAnswer: Boolean,
+    avatarUrl: String = "",
+  ) {
+    if (autoAnswer) {
+      pendingAutoAnswer.add(uuid)
+    }
+    addCall(
+      uuid = uuid,
+      handle = handle,
+      callerName = callerName,
+      hasVideo = hasVideo,
+      direction = CallAttributesCompat.DIRECTION_INCOMING,
+      avatarUrl = avatarUrl,
+    )
+  }
+
+  fun startCall(
+    uuid: String,
+    handle: String,
+    callerName: String,
+    hasVideo: Boolean,
+    avatarUrl: String = "",
+  ) {
+    addCall(
+      uuid = uuid,
+      handle = handle,
+      callerName = callerName,
+      hasVideo = hasVideo,
+      direction = CallAttributesCompat.DIRECTION_OUTGOING,
+      avatarUrl = avatarUrl,
+    )
+  }
+
+  fun answerCall(uuid: String) {
+    scope.launch {
+      val session = sessions[uuid]
+      if (session == null) {
+        android.util.Log.w(TAG, "answerCall ignored — no session for $uuid")
+        return@launch
+      }
+
+      TelecomRingtonePlayer.stop()
+      TelecomCallUi.finishIncoming(context, uuid)
+
+      val result = session.answer()
+      android.util.Log.i(TAG, "answerCall uuid=$uuid result=$result")
+      audioRouter.activate(uuid)
+      emit(
+        EVENT_ANSWER_CALL,
+        Arguments.createMap().apply {
+          putString("callUUID", uuid)
+        },
+      )
+
+      TelecomCallService.updateOngoing(
+        context = context,
+        uuid = uuid,
+        callerName = session.displayName,
+        handle = session.handle,
+        avatarUrl = session.avatarUrl,
+      )
+      TelecomCallService.openInCall(
+        context = context,
+        uuid = uuid,
+        callerName = session.displayName,
+        handle = session.handle,
+        direction = "incoming",
+        avatarUrl = session.avatarUrl,
+      )
+    }
+  }
+
+  fun endCall(uuid: String) {
+    scope.launch {
+      TelecomRingtonePlayer.stop()
+      TelecomCallUi.finishAll(context, uuid)
+      val session = sessions.remove(uuid)
+      starting.remove(uuid)
+      pendingAutoAnswer.remove(uuid)
+      if (session != null) {
+        session.disconnect(DisconnectCause(DisconnectCause.LOCAL))
+      }
+      if (sessions.isEmpty()) {
+        audioRouter.deactivate(uuid)
+      }
+      maybeStopCallUi()
+      emit(
+        EVENT_END_CALL,
+        Arguments.createMap().apply {
+          putString("callUUID", uuid)
+        },
+      )
+    }
+  }
+
+  fun endAllCalls() {
+    scope.launch {
+      TelecomRingtonePlayer.stop()
+      TelecomCallUi.finishAll(context)
+      sessions.keys.toList().forEach { uuid ->
+        val session = sessions.remove(uuid)
+        starting.remove(uuid)
+        pendingAutoAnswer.remove(uuid)
+        session?.disconnect(DisconnectCause(DisconnectCause.LOCAL))
+        emit(
+          EVENT_END_CALL,
+          Arguments.createMap().apply {
+            putString("callUUID", uuid)
+          },
+        )
+      }
+      audioRouter.deactivate()
+      TelecomCallService.stop(context)
+    }
+  }
+
+  fun setMuted(uuid: String, muted: Boolean) {
+    if (!sessions.containsKey(uuid)) {
+      android.util.Log.w(TAG, "setMuted ignored — no active session for $uuid")
+      return
+    }
+
+    val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+    audioManager.isMicrophoneMute = muted
+    android.util.Log.i(TAG, "setMuted uuid=$uuid muted=$muted actual=${audioManager.isMicrophoneMute}")
+
+    emit(
+      EVENT_DID_CHANGE_MUTE_STATE,
+      Arguments.createMap().apply {
+        putString("callUUID", uuid)
+        putBoolean("muted", muted)
+      },
+    )
+  }
+
+  fun setAudioRoute(uuid: String, route: String) {
+    if (!sessions.containsKey(uuid)) return
+    audioRouter.setRoute(uuid, route)
+  }
+
+  fun getAvailableAudioRoutes(): WritableArray = audioRouter.getAvailableRoutes()
+
+  fun cycleAudioRoute(uuid: String): String {
+    if (!sessions.containsKey(uuid)) return audioRouter.currentRouteId()
+    return audioRouter.cycleRoute(uuid)
+  }
+
+  fun currentAudioRoute(): String = audioRouter.currentRouteId()
+
+  fun sendDtmf(uuid: String, digits: String) {
+    if (!sessions.containsKey(uuid)) return
+    scope.launch(Dispatchers.Default) {
+      var tone: ToneGenerator? = null
+      try {
+        tone = ToneGenerator(AudioManager.STREAM_DTMF, 80)
+        digits.forEach { ch ->
+          val digit = ch.toString()
+          val toneType = dtmfTone(digit) ?: return@forEach
+          try {
+            tone.startTone(toneType, 160)
+          } catch (_: Exception) {
+          }
+          emit(
+            EVENT_DTMF,
+            Arguments.createMap().apply {
+              putString("callUUID", uuid)
+              putString("digit", digit)
+            },
+          )
+          delay(180)
+        }
+      } catch (_: Exception) {
+      } finally {
+        tone?.release()
+      }
+    }
+  }
+
+  fun emitSpeakerChanged(uuid: String, speakerOn: Boolean) {
+    setAudioRoute(uuid, if (speakerOn) "speaker" else "earpiece")
+  }
+
+  fun emitDtmf(uuid: String, digit: String) {
+    emit(
+      EVENT_DTMF,
+      Arguments.createMap().apply {
+        putString("callUUID", uuid)
+        putString("digit", digit)
+      },
+    )
+  }
+
+  fun setOnHold(uuid: String, hold: Boolean) {
+    scope.launch {
+      val session = sessions[uuid]
+      if (session == null) {
+        android.util.Log.w(TAG, "setOnHold ignored — no active session for $uuid")
+        return@launch
+      }
+
+      val result =
+        if (hold) {
+          session.setInactive()
+        } else {
+          session.setActive()
+        }
+      android.util.Log.i(TAG, "setOnHold uuid=$uuid hold=$hold result=$result")
+
+      emit(
+        EVENT_DID_CHANGE_HOLD_STATE,
+        Arguments.createMap().apply {
+          putString("callUUID", uuid)
+          putBoolean("hold", hold)
+        },
+      )
+    }
+  }
+
+  private fun addCall(
+    uuid: String,
+    handle: String,
+    callerName: String,
+    hasVideo: Boolean,
+    direction: Int,
+    avatarUrl: String,
+  ) {
+    if (!registered) {
+      setup(supportsVideo = true)
+    }
+
+    ensureManageOwnCallsPermission()
+
+    if (sessions.containsKey(uuid) || !starting.add(uuid)) {
+      return
+    }
+
+    val address = Uri.parse("tel:${handle.ifBlank { "unknown" }}")
+    val callType =
+      if (hasVideo) {
+        CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+      } else {
+        CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+      }
+
+    val attributes =
+      CallAttributesCompat(
+        displayName = callerName.ifBlank { handle }.ifBlank { "Unknown" },
+        address = address,
+        direction = direction,
+        callType = callType,
+        callCapabilities = CallAttributesCompat.SUPPORTS_SET_INACTIVE,
+      )
+
+    val directionLabel =
+      if (direction == CallAttributesCompat.DIRECTION_INCOMING) {
+        "incoming"
+      } else {
+        "outgoing"
+      }
+
+    scope.launch {
+      try {
+        callsManager.addCall(
+          callAttributes = attributes,
+          onAnswer = { _ ->
+            emit(
+              EVENT_ANSWER_CALL,
+              Arguments.createMap().apply {
+                putString("callUUID", uuid)
+              },
+            )
+          },
+          onDisconnect = { _ ->
+            sessions.remove(uuid)
+            starting.remove(uuid)
+            pendingAutoAnswer.remove(uuid)
+            TelecomRingtonePlayer.stop()
+            TelecomCallUi.finishAll(context, uuid)
+            if (sessions.isEmpty()) {
+              audioRouter.deactivate(uuid)
+            }
+            maybeStopCallUi()
+            emit(
+              EVENT_END_CALL,
+              Arguments.createMap().apply {
+                putString("callUUID", uuid)
+              },
+            )
+          },
+          onSetActive = {
+            emit(
+              EVENT_DID_CHANGE_HOLD_STATE,
+              Arguments.createMap().apply {
+                putString("callUUID", uuid)
+                putBoolean("hold", false)
+              },
+            )
+          },
+          onSetInactive = {
+            emit(
+              EVENT_DID_CHANGE_HOLD_STATE,
+              Arguments.createMap().apply {
+                putString("callUUID", uuid)
+                putBoolean("hold", true)
+              },
+            )
+          },
+        ) {
+          val session = CallSession(uuid, this, hasVideo, callerName, handle, avatarUrl)
+          sessions[uuid] = session
+          starting.remove(uuid)
+
+          TelecomCallService.start(
+            context = context,
+            uuid = uuid,
+            callerName = callerName.ifBlank { handle }.ifBlank { "Unknown" },
+            handle = handle,
+            direction = directionLabel,
+            skipIncomingUi = pendingAutoAnswer.contains(uuid),
+            avatarUrl = avatarUrl,
+          )
+
+          emit(
+            EVENT_DID_DISPLAY_INCOMING_CALL,
+            Arguments.createMap().apply {
+              putString("callUUID", uuid)
+              putString("handle", handle)
+              putString("callerName", callerName)
+              putBoolean("hasVideo", hasVideo)
+              putString("direction", directionLabel)
+              putString("avatarUrl", avatarUrl)
+            },
+          )
+
+          if (direction == CallAttributesCompat.DIRECTION_OUTGOING) {
+            launch {
+              setActive()
+              audioRouter.activate(uuid)
+            }
+          }
+
+          if (pendingAutoAnswer.remove(uuid)) {
+            launch {
+              delay(350)
+              answerCall(uuid)
+            }
+          }
+        }
+      } catch (error: Exception) {
+        sessions.remove(uuid)
+        starting.remove(uuid)
+        pendingAutoAnswer.remove(uuid)
+        maybeStopCallUi()
+        emit(
+          EVENT_END_CALL,
+          Arguments.createMap().apply {
+            putString("callUUID", uuid)
+            putString("error", error.message ?: "Failed to add call")
+          },
+        )
+      }
+    }
+  }
+
+  private fun maybeStopCallUi() {
+    if (sessions.isEmpty()) {
+      TelecomCallService.stop(context)
+    }
+  }
+
+  private fun ensureManageOwnCallsPermission() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      throw IllegalStateException("react-native-telecom requires Android 8.0 (API 26)+")
+    }
+
+    val granted =
+      ContextCompat.checkSelfPermission(
+        context,
+        Manifest.permission.MANAGE_OWN_CALLS,
+      ) == PackageManager.PERMISSION_GRANTED
+
+    if (!granted) {
+      throw SecurityException(
+        "Missing android.permission.MANAGE_OWN_CALLS. See docs/android-setup.md"
+      )
+    }
+  }
+
+  private fun dtmfTone(digit: String): Int? {
+    return when (digit) {
+      "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 -> null
+    }
+  }
+
+  companion object {
+    private const val TAG = "RNTelecom"
+
+    @Volatile
+    var instance: CallSessionManager? = null
+
+    const val EVENT_ANSWER_CALL = "answerCall"
+    const val EVENT_END_CALL = "endCall"
+    const val EVENT_DID_DISPLAY_INCOMING_CALL = "didDisplayIncomingCall"
+    const val EVENT_DID_CHANGE_HOLD_STATE = "didChangeHoldState"
+    const val EVENT_DID_CHANGE_MUTE_STATE = "didChangeMuteState"
+    const val EVENT_DID_CHANGE_SPEAKER = "didChangeSpeaker"
+    const val EVENT_DTMF = "dtmfTone"
+  }
+}

package/android/src/main/java/com/telecom/TelecomAudioRouter.kt

@@ -0,0 +1,227 @@
+package com.telecom
+
+import android.Manifest
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothProfile
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * VoIP audio routes: earpiece, speaker, bluetooth SCO.
+ * Call [activate] when a call becomes active; [deactivate] when all calls end.
+ */
+internal class TelecomAudioRouter(
+  private val context: Context,
+  private val emit: (eventName: String, params: WritableMap) -> Unit,
+) {
+  enum class Route(val id: String) {
+    EARPIECE("earpiece"),
+    SPEAKER("speaker"),
+    BLUETOOTH("bluetooth"),
+  }
+
+  private val am = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  private var current: Route = Route.EARPIECE
+  private var focusRequest: android.media.AudioFocusRequest? = null
+
+  fun activate(uuid: String) {
+    am.mode = AudioManager.MODE_IN_COMMUNICATION
+    requestFocus()
+    applyRoute(current)
+    emit(
+      EVENT_AUDIO_ACTIVATED,
+      Arguments.createMap().apply {
+        putString("callUUID", uuid)
+        putString("route", current.id)
+      },
+    )
+    Log.i(TAG, "audio session activated uuid=$uuid route=${current.id}")
+  }
+
+  fun deactivate(uuid: String? = null) {
+    stopBluetoothSco()
+    @Suppress("DEPRECATION")
+    am.isSpeakerphoneOn = false
+    am.mode = AudioManager.MODE_NORMAL
+    abandonFocus()
+    emit(
+      EVENT_AUDIO_DEACTIVATED,
+      Arguments.createMap().apply {
+        if (!uuid.isNullOrBlank()) putString("callUUID", uuid)
+      },
+    )
+    Log.i(TAG, "audio session deactivated")
+  }
+
+  fun setRoute(uuid: String, routeId: String) {
+    val route =
+      Route.entries.find { it.id == routeId }
+        ?: run {
+          Log.w(TAG, "unknown route=$routeId")
+          return
+        }
+    current = route
+    am.mode = AudioManager.MODE_IN_COMMUNICATION
+    applyRoute(route)
+    emit(
+      EVENT_DID_CHANGE_AUDIO_ROUTE,
+      Arguments.createMap().apply {
+        putString("callUUID", uuid)
+        putString("route", route.id)
+      },
+    )
+    // Back-compat for older listeners.
+    emit(
+      CallSessionManager.EVENT_DID_CHANGE_SPEAKER,
+      Arguments.createMap().apply {
+        putString("callUUID", uuid)
+        putBoolean("speakerOn", route == Route.SPEAKER)
+      },
+    )
+  }
+
+  fun getAvailableRoutes(): WritableArray {
+    val list = Arguments.createArray()
+    list.pushMap(routeMap(Route.EARPIECE, "Phone", true))
+    list.pushMap(routeMap(Route.SPEAKER, "Speaker", true))
+    list.pushMap(routeMap(Route.BLUETOOTH, "Bluetooth", isBluetoothAvailable()))
+    return list
+  }
+
+  fun currentRouteId(): String = current.id
+
+  fun cycleRoute(uuid: String): String {
+    val available =
+      listOf(Route.EARPIECE, Route.SPEAKER, Route.BLUETOOTH).filter { route ->
+        route != Route.BLUETOOTH || isBluetoothAvailable()
+      }
+    val idx = available.indexOf(current).let { if (it < 0) 0 else (it + 1) % available.size }
+    val next = available[idx]
+    setRoute(uuid, next.id)
+    return next.id
+  }
+
+  private fun applyRoute(route: Route) {
+    when (route) {
+      Route.SPEAKER -> {
+        stopBluetoothSco()
+        @Suppress("DEPRECATION")
+        am.isSpeakerphoneOn = true
+      }
+      Route.EARPIECE -> {
+        stopBluetoothSco()
+        @Suppress("DEPRECATION")
+        am.isSpeakerphoneOn = false
+      }
+      Route.BLUETOOTH -> {
+        @Suppress("DEPRECATION")
+        am.isSpeakerphoneOn = false
+        startBluetoothSco()
+      }
+    }
+  }
+
+  private fun startBluetoothSco() {
+    try {
+      @Suppress("DEPRECATION")
+      am.startBluetoothSco()
+      @Suppress("DEPRECATION")
+      am.isBluetoothScoOn = true
+    } catch (error: Exception) {
+      Log.w(TAG, "startBluetoothSco failed: ${error.message}")
+    }
+  }
+
+  private fun stopBluetoothSco() {
+    try {
+      @Suppress("DEPRECATION")
+      am.isBluetoothScoOn = false
+      @Suppress("DEPRECATION")
+      am.stopBluetoothSco()
+    } catch (_: Exception) {
+    }
+  }
+
+  private fun isBluetoothAvailable(): Boolean {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val granted =
+        ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) ==
+          PackageManager.PERMISSION_GRANTED
+      if (!granted) return false
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      val devices = am.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
+      if (devices.any { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO || it.type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP }) {
+        return true
+      }
+    }
+    return try {
+      val adapter = BluetoothAdapter.getDefaultAdapter() ?: return false
+      adapter.isEnabled && adapter.getProfileConnectionState(BluetoothProfile.HEADSET) ==
+        BluetoothAdapter.STATE_CONNECTED
+    } catch (_: SecurityException) {
+      false
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  private fun requestFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val attrs =
+        android.media.AudioAttributes.Builder()
+          .setUsage(android.media.AudioAttributes.USAGE_VOICE_COMMUNICATION)
+          .setContentType(android.media.AudioAttributes.CONTENT_TYPE_SPEECH)
+          .build()
+      val req =
+        android.media.AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+          .setAudioAttributes(attrs)
+          .setAcceptsDelayedFocusGain(true)
+          .setOnAudioFocusChangeListener { }
+          .build()
+      focusRequest = req
+      am.requestAudioFocus(req)
+    } else {
+      @Suppress("DEPRECATION")
+      am.requestAudioFocus(
+        null,
+        AudioManager.STREAM_VOICE_CALL,
+        AudioManager.AUDIOFOCUS_GAIN,
+      )
+    }
+  }
+
+  private fun abandonFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      focusRequest?.let { am.abandonAudioFocusRequest(it) }
+      focusRequest = null
+    } else {
+      @Suppress("DEPRECATION")
+      am.abandonAudioFocus(null)
+    }
+  }
+
+  private fun routeMap(route: Route, name: String, available: Boolean): WritableMap {
+    return Arguments.createMap().apply {
+      putString("id", route.id)
+      putString("name", name)
+      putBoolean("available", available)
+      putBoolean("selected", current == route)
+    }
+  }
+
+  companion object {
+    private const val TAG = "RNTelecomAudio"
+    const val EVENT_AUDIO_ACTIVATED = "didActivateAudioSession"
+    const val EVENT_AUDIO_DEACTIVATED = "didDeactivateAudioSession"
+    const val EVENT_DID_CHANGE_AUDIO_ROUTE = "didChangeAudioRoute"
+  }
+}