Présentation du framework de télécommunications

Le framework Android Telecom (également appelé simplement "Telecom") gère les appels audio et vidéo sur un appareil Android. Cela inclut les appels basés sur la carte SIM, tels que les appels qui utilisent le framework de téléphonie, et les appels VoIP qui implémentent la bibliothèque Jetpack Core-Telecom.

Les principaux composants gérés par Telecom sont ConnectionService et InCallService.

Une implémentation ConnectionService s'appuie sur des technologies telles que le RTPC pour connecter les appels à d'autres correspondants. L'implémentation ConnectionService la plus courante sur un téléphone est l'ConnectionService de téléphonie. Il connecte les appels de l'opérateur.

Une implémentation InCallService fournit une interface utilisateur aux appels gérés par Telecom et permet à l'utilisateur de contrôler ces appels et d'interagir avec eux. L'implémentation la plus courante d'un InCallService est l'application Téléphone fournie avec un appareil.

Le secteur des télécommunications agit comme un standard téléphonique. Il achemine les appels fournis par les implémentations ConnectionService vers les interfaces utilisateur d'appel fournies par les implémentations InCallService.

Vous pouvez implémenter les API Telecom pour les raisons suivantes :

Créer une application Téléphone de remplacement

Pour créer une application de remplacement de l'application Téléphone par défaut sur un appareil Android, implémentez l'API InCallService. Votre implémentation doit répondre aux exigences suivantes :

  • Il ne doit pas disposer de fonctionnalités d'appel et doit se composer uniquement de l'interface utilisateur pour les appels.
  • Il doit gérer tous les appels dont le framework Telecom a connaissance et ne pas faire d'hypothèses sur la nature des appels. Par exemple, elle ne doit pas supposer que les appels sont des appels téléphoniques basés sur une carte SIM, ni implémenter des restrictions d'appel basées sur un seul ConnectionService, comme l'application de restrictions téléphoniques pour les appels vidéo.

Pour en savoir plus, consultez les sections sur InCallService

Intégrer une solution d'appel

Pour intégrer votre solution d'appel à Android, vous disposez des options suivantes :

  • Implémenter la bibliothèque Jetpack Core-Telecom autogérée : cette option est idéale pour les développeurs d'applications d'appel autonomes qui ne souhaitent pas afficher leurs appels dans l'application Téléphone par défaut, ni afficher d'autres appels dans leur interface utilisateur.

    Lorsque vous intégrez la bibliothèque Jetpack Core-Telecom, vous aidez votre application à interagir non seulement avec les appels téléphoniques du système sur l'appareil, mais aussi avec d'autres applications d'appel autonomes qui s'intègrent à Telecom. La bibliothèque Core-Telecom gère également le routage et la sélection audio. Pour en savoir plus, consultez Créer une application d'appel.

  • Implémenter l'API ConnectionService gérée : cette option facilite le développement d'une solution d'appel qui s'appuie sur l'application de téléphonie existante de l'appareil pour fournir l'interface utilisateur des appels. Par exemple, une implémentation tierce des services d'appel SIP et VoIP. Pour en savoir plus, consultez getDefaultDialerPackage().

    Un ConnectionService ne fournit que les moyens de connecter les appels. Il n'est associé à aucune interface utilisateur.

  • Implémenter les API InCallService et ConnectionService : cette option est idéale si vous souhaitez créer votre propre solution d'appel basée sur ConnectionService, avec sa propre interface utilisateur, et afficher tous les autres appels Android dans la même interface utilisateur. Lorsque vous utilisez cette approche, votre implémentation de InCallService ne doit pas faire d'hypothèses sur les sources des appels qu'elle affiche. De plus, votre implémentation de ConnectionService doit continuer à fonctionner sans que l'application Téléphone par défaut soit définie sur votre InCallService personnalisé.

Identifier l'appelant

Les appareils équipés d'Android 10 (niveau d'API 29) ou version ultérieure permettent à votre application d'identifier les appels provenant de numéros qui ne figurent pas dans le carnet d'adresses de l'utilisateur comme des appels indésirables potentiels. Les utilisateurs peuvent choisir de rejeter silencieusement les appels indésirables. Pour offrir plus de transparence aux utilisateurs lorsqu'ils manquent des appels, les informations sur ces appels bloqués sont enregistrées dans le journal d'appels. L'utilisation de l'API Android 10 élimine l'obligation d'obtenir l'autorisation READ_CALL_LOG de l'utilisateur pour fournir des fonctionnalités de filtrage d'appels et d'identification de l'appelant.

Vous utilisez une implémentation CallScreeningService pour filtrer les appels. Appelez la fonction onScreenCall() pour tout nouvel appel entrant ou sortant lorsque le numéro ne figure pas dans la liste de contacts de l'utilisateur. Vous pouvez consulter l'objet Call.Details pour obtenir des informations sur l'appel. Plus précisément, la fonction getCallerNumberVerificationStatus() inclut des informations du fournisseur de réseau sur l'autre numéro. Si l'état de validation est "Échec", cela indique que l'appel provient d'un numéro non valide ou qu'il s'agit d'un appel potentiellement indésirable.

class ScreeningService : CallScreeningService() {
    // This function is called when an ingoing or outgoing call
    // is from a number not in the user's contacts list
    override fun onScreenCall(callDetails: Call.Details) {
        // Can check the direction of the call
        val isIncoming = callDetails.callDirection == Call.Details.DIRECTION_INCOMING

        if (isIncoming) {
            // the handle (e.g. phone number) that the Call is currently connected to
            val handle: Uri = callDetails.handle

            // determine if you want to allow or reject the call
            when (callDetails.callerNumberVerificationStatus) {
                Connection.VERIFICATION_STATUS_FAILED -> {
                    // Network verification failed, likely an invalid/spam call.
                }
                Connection.VERIFICATION_STATUS_PASSED -> {
                    // Network verification passed, likely a valid call.
                }
                else -> {
                    // Network could not perform verification.
                    // This branch matches Connection.VERIFICATION_STATUS_NOT_VERIFIED.
                }
            }
        }
    }
}

Définissez la fonction onScreenCall() pour appeler respondToCall() afin d'indiquer au système comment répondre au nouvel appel. Cette fonction accepte un paramètre CallResponse que vous pouvez utiliser pour indiquer au système de bloquer l'appel, de le rejeter comme si l'utilisateur l'avait fait ou de le couper. Vous pouvez également indiquer au système de ne pas ajouter cet appel au journal d'appels de l'appareil.

// Tell the system how to respond to the incoming call
// and if it should notify the user of the call.
val response = CallResponse.Builder()
    // Sets whether the incoming call should be blocked.
    .setDisallowCall(false)
    // Sets whether the incoming call should be rejected as if the user did so manually.
    .setRejectCall(false)
    // Sets whether ringing should be silenced for the incoming call.
    .setSilenceCall(false)
    // Sets whether the incoming call should not be displayed in the call log.
    .setSkipCallLog(false)
    // Sets whether a missed call notification should not be shown for the incoming call.
    .setSkipNotification(false)
    .build()

// Call this function to provide your screening response.
respondToCall(callDetails, response)

Vous devez enregistrer l'implémentation CallScreeningService dans le fichier manifeste avec le filtre d'intent et l'autorisation appropriés pour que le système puisse la déclencher correctement.

<service
    android:name=".ScreeningService"
    android:permission="android.permission.BIND_SCREENING_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.CallScreeningService" />
    </intent-filter>
</service>

Rediriger un appel

Les appareils équipés d'Android 10 ou version ultérieure gèrent les intents d'appel différemment de ceux équipés d'Android 9 ou version antérieure. Sur Android 10 et versions ultérieures, la diffusion ACTION_NEW_OUTGOING_CALL est obsolète et remplacée par l'API CallRedirectionService. CallRedirectionService fournit des interfaces que vous pouvez utiliser pour modifier les appels sortants effectués par la plate-forme Android. Par exemple, des applications tierces peuvent annuler des appels et les rediriger via VoIP.

class RedirectionService : CallRedirectionService() {
    override fun onPlaceCall(
        handle: Uri,
        initialPhoneAccount: PhoneAccountHandle,
        allowInteractiveResponse: Boolean
    ) {
        // Determine if the call should proceed, be redirected, or cancelled.
        val callShouldProceed = true
        val callShouldRedirect = false
        when {
            callShouldProceed -> {
                placeCallUnmodified()
            }
            callShouldRedirect -> {
                // Update the URI to point to a different phone number or modify the
                // PhoneAccountHandle and redirect.
                redirectCall(handle, initialPhoneAccount, true)
            }
            else -> {
                cancelCall()
            }
        }
    }
}

Vous devez enregistrer ce service dans le fichier manifeste pour que le système puisse le démarrer correctement.

<service
    android:name=".RedirectionService"
    android:permission="android.permission.BIND_CALL_REDIRECTION_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.CallRedirectionService"/>
    </intent-filter>
</service>

Pour utiliser un service de redirection, votre application doit demander le rôle de redirection d'appel à partir de RoleManager. L'utilisateur sera alors invité à autoriser votre application à gérer les redirections d'appels. Si ce rôle n'est pas accordé à votre application, votre service de redirection n'est pas utilisé.

Vous devez vérifier si votre application dispose de ce rôle lorsque l'utilisateur la lance, afin de pouvoir le demander si nécessaire. Vous lancez un intent créé par RoleManager. Veillez donc à remplacer la fonction onActivityResult() pour gérer la sélection de l'utilisateur.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Tell the system that you want your app to handle call redirects. This
        // is done by using the RoleManager to register your app to handle redirects.
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
            val roleManager = getSystemService(Context.ROLE_SERVICE) as RoleManager
            // Check if the app needs to register call redirection role.
            val shouldRequestRole = roleManager.isRoleAvailable(RoleManager.ROLE_CALL_REDIRECTION) &&
                !roleManager.isRoleHeld(RoleManager.ROLE_CALL_REDIRECTION)
            if (shouldRequestRole) {
                val intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_REDIRECTION)
                startActivityForResult(intent, REDIRECT_ROLE_REQUEST_CODE)
            }
        }
    }

    companion object {
        private const val REDIRECT_ROLE_REQUEST_CODE = 1
    }
}