Présentation du framework de télécommunications

Le framework Android Telecom (également appelé simplement "Telecom") gère l'audio et des appels vidéo sur un appareil Android. Cela inclut les appels par carte SIM, tels que appels qui utilisent le framework de téléphonie, et les appels VoIP qui implémentent le API ConnectionService.

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

Une implémentation de ConnectionService utilise des technologies telles que la VoIP pour se connecter appels à d'autres parties. L'implémentation ConnectionService la plus courante sur un le téléphone correspond au ConnectionService de téléphonie. Il connecte les appels via 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. Les plus L'implémentation courante d'un InCallService est l'application pour téléphone fournie avec un appareil.

Les télécommunications font office de standard. Il achemine les appels que ConnectionService fournies par les implémentations aux interfaces utilisateur appelantes InCallService implémentations fournissent.

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

• Pour créer un remplacement pour l'application pour téléphone système.
• Intégrer une solution d'appel dans l'expérience d'appel Android.

Créer une application pour téléphone de remplacement

Pour remplacer l'application par défaut pour téléphone sur un appareil Android, procédez comme suit : implémenter l'API InCallService. Votre implémentation doit répondre aux critères suivants configuration requise:

• Il ne doit pas avoir de capacité d'appel et doit être uniquement constitué de l'utilisateur pour les appels.
• Il doit gérer tous les appels dont le framework de télécommunications a connaissance, et ne doit pas effectuer sur la nature des appels. Par exemple, vous ne devez pas supposer sont des appels téléphoniques basés sur la carte SIM et ne mettent pas en œuvre de restrictions d'appel qui se basent sur un ConnectionService, par exemple l'application des règles des restrictions pour les appels vidéo.

Pour en savoir plus, consultez InCallService.

Intégrer une solution d'appel

Pour intégrer votre solution d'appel dans Android, vous devez disposer du les options suivantes:

• Implémentez l'API ConnectionService autogérée: Cette option est idéale pour les développeurs d'applications d'appel autonomes pour afficher leurs appels dans l'application Téléphone par défaut et que les autres appels ne s'affichent pas dans leur interface utilisateur.

  Lorsque vous utilisez un ConnectionService autogéré, vous aidez votre application à : interagissent non seulement avec les appels téléphoniques natifs sur l'appareil, mais aussi avec d'autres applications d'appel autonomes qui implémentent cette API. Le service autogéré L'API ConnectionService gère également le routage et la sélection audio. Pour en savoir plus, consultez Créez une application d'appel.

• Implémentez l'API ConnectionService gérée: Cette option facilite le développement d'une solution d'appel qui repose sur application téléphonique existante pour fournir l'interface utilisateur pour les appels. Exemples : implémentation tierce des appels SIP et VoIP services. Pour en savoir plus, consultez getDefaultDialerPackage()

  À lui seul, un ConnectionService ne fournit que le moyen de connecter des appels. Il n'est associée à aucune interface utilisateur.

• Implémentez les API InCallService et ConnectionService: Cette option est idéale si vous souhaitez créer votre propre Solution d'appel basée sur ConnectionService, dotée de son propre 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 des hypothèses sur les sources des appels qu'il affiche. De plus, votre l'implémentation de ConnectionService doit continuer à fonctionner sans application de téléphone par défaut 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 appels provenant de numéros ne figurant pas dans le carnet d'adresses de l'utilisateur, considérés comme du spam potentiel ; appels. Les utilisateurs peuvent choisir de rejeter les appels indésirables en mode silencieux. Afin de fournir une meilleure la transparence pour les utilisateurs lorsqu'ils manquent des appels, les informations sur les est consigné dans le journal d'appels. L'utilisation de l'API Android 10 élimine le exigence pour obtenir READ_CALL_LOG autorisation de l'utilisateur pour permettre le filtrage d'appel et l'affichage du numéro de l'appelant de Google Cloud.

Vous utilisez un CallScreeningService pour filtrer les appels. Appelez la méthode onScreenCall() pour tout nouvel appel entrant ou sortant lorsque le numéro n'est pas dans le de la liste de contacts de l'utilisateur. Vous pouvez consulter Objet Call.Details pour les informations à propos de l'appel. Plus précisément, getCallerNumberVerificationStatus() inclut des informations du fournisseur de réseau sur l'autre numéro. Si l'état de la vérification a échoué, cela indique que l'appel est à partir d'un numéro non valide ou d'un appel indésirable potentiel.

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.
                }
            }
        }
    }
}

class ScreeningService extends CallScreeningService {
    @Override
    public void onScreenCall(@NonNull Call.Details callDetails) {
        boolean isIncoming = callDetails.getCallDirection() == Call.Details.DIRECTION_INCOMING;

        if (isIncoming) {
            Uri handle = callDetails.getHandle();

            switch (callDetails.getCallerNumberVerificationStatus()) {
                case Connection.VERIFICATION_STATUS_FAILED:
                    // Network verification failed, likely an invalid/spam call.
                    break;
                case Connection.VERIFICATION_STATUS_PASSED:
                    // Network verification passed, likely a valid call.
                    break;
                default:
                    // Network could not perform verification.
                    // This branch matches Connection.VERIFICATION_STATUS_NOT_VERIFIED
            }
        }
    }
}

Définissez la fonction onScreenCall() pour appeler respondToCall() pour indiquer au système comment répondre au nouvel appel. Cette fonction utilise CallResponse que vous pouvez utiliser pour indiquer au système de bloquer l'appel et de le rejeter l'utilisateur l'a fait, ou l'a coupée. Vous pouvez également demander au système de ne pas ajouter cette 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)

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

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

Vous devez enregistrer l'implémentation de CallScreeningService dans le fichier manifeste avec le filtre d'intent et l'autorisation appropriés pour que le système 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 les appareils équipés d'Android 9 ou version antérieure. Sur Android 10 ou version ultérieure, le ACTION_NEW_OUTGOING_CALL diffusion est obsolète et a été remplacée par CallRedirectionService API. CallRedirectionService fournit des interfaces que vous pouvez utiliser pour modifier les appels sortants passés par la plate-forme Android. Par exemple, les données applications peuvent annuler les 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()
            }
        }
    }
}

class RedirectionService extends CallRedirectionService {
    @Override
    public void onPlaceCall(
            @NonNull Uri handle,
            @NonNull PhoneAccountHandle initialPhoneAccount,
            boolean allowInteractiveResponse
    ) {
        // Determine if the call should proceed, be redirected, or cancelled.
        // Your app should implement this logic to determine the redirection.
        boolean callShouldProceed = true;
        boolean callShouldRedirect = false;
        if (callShouldProceed) {
            placeCallUnmodified();
        } else if (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 des appels à partir de RoleManager. Vous allez demander l'utilisateur s'il souhaite autoriser votre application à gérer les redirections d'appel. Si votre application ne dispose pas de ce rôle, votre service de redirection n'est pas utilisé.

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

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 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
    }
}

class MainActivity extends AppCompatActivity {
    private static final int REDIRECT_ROLE_REQUEST_CODE = 0;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 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) {
            RoleManager roleManager = (RoleManager) getSystemService(Context.ROLE_SERVICE);
            // Check if the app needs to register call redirection role.
            boolean shouldRequestRole = roleManager.isRoleAvailable(RoleManager.ROLE_CALL_REDIRECTION) &&
                    !roleManager.isRoleHeld(RoleManager.ROLE_CALL_REDIRECTION);
            if (shouldRequestRole) {
                Intent intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_REDIRECTION);
                startActivityForResult(intent, REDIRECT_ROLE_REQUEST_CODE);
            }
        }
    }
}