Créer une application de téléphone par défaut

Une application téléphonique par défaut permet au framework Android Telecom d'informer votre application de l'état de l'appel en utilisant le gestionnaire de rôles et le service d'appel pour remplacer l'application pour téléphone par défaut sur un appareil Android et implémenter l'API InCallService. Votre mise en œuvre doit répondre aux exigences suivantes:

Il ne doit pas avoir de capacité d'appel et doit se composer uniquement de l'interface utilisateur pour l'appel. Il doit gérer tous les appels dont le framework Telecom a connaissance, et ne doit pas faire de suppositions sur leur nature. Par exemple, elle ne doit pas supposer que les appels sont basés sur une carte SIM et ne doit pas non plus appliquer de restrictions d'appel basées sur un service ConnectionService spécifique, comme l'application de restrictions de téléphonie pour les appels vidéo.

Une application d'appel permet aux utilisateurs de recevoir ou de passer des appels audio ou vidéo sur leur appareil. Les applications d'appel utilisent leur propre interface utilisateur pour les appels au lieu d'utiliser l'interface par défaut de l'application Téléphone, comme illustré dans la capture d'écran suivante.


Exemple d'application appelante Exemple d'application appelante utilisant sa propre interface utilisateur

Le framework Android inclut le package android.telecom, qui contient des classes qui vous aident à créer une application d'appel en fonction du protocole d'infrastructure. Créer votre application selon le framework de télécommunications offre les avantages suivants : les avantages suivants:

  • Votre application interagit correctement avec le sous-système de télécommunications natif appareil.
  • Votre application fonctionne correctement avec les autres applications d'appel qui respectent également les le cadre.
  • Le framework aide votre application à gérer le routage audio et vidéo.
  • Le framework aide votre application à déterminer si ses appels sont ciblés.

Déclarations et autorisations du fichier manifeste

Dans le fichier manifeste de votre application, déclarez que celle-ci utilise la MANAGE_OWN_CALLS l'autorisation, comme illustré dans l'exemple suivant:

<manifest … >
    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
</manifest>

Pour en savoir plus sur la déclaration d'autorisations d'application, consultez Autorisations :

Vous devez déclarer un service qui spécifie la classe qui implémente la ConnectionService dans votre application. Le secteur des télécommunications nécessite que le service déclare l'autorisation BIND_TELECOM_CONNECTION_SERVICE comme étant capable de s'y associer. L'exemple suivant montre comment déclarer le service dans le fichier manifeste de votre application:

<service android:name="com.example.MyConnectionService"
    android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.ConnectionService" />
    </intent-filter>
</service>

Pour en savoir plus sur la déclaration de composants d'application, y compris de services, consultez Composants de l'application :

Implémenter le service de connexion

Votre application appelante doit fournir une implémentation de la classe ConnectionService à laquelle le sous-système de télécommunications peut être lié. Votre implémentation de ConnectionService doit remplacer les méthodes suivantes:

onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)

Le sous-système de télécommunications appelle cette méthode en réponse à votre application appelle placeCall(Uri, Bundle) pour créer un appel sortant. Votre application renvoie une nouvelle instance de l'implémentation de la classe Connection (pour en savoir plus, consultez Implémenter la connexion) pour représenter le nouveau appel sortant. Vous pouvez personnaliser davantage la connexion sortante en effectuant les actions suivantes:

onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

Le sous-système de télécommunications appelle cette méthode lorsque votre application appelle la méthode placeCall(Uri, Bundle) et que l'appel sortant ne peut pas être placées. En réponse à cette situation, votre application doit informer l'utilisateur (pour par exemple, en utilisant une zone d'alerte ou un toast) indiquant que l'appel sortant n'a pas pu être n'est pas placé. Il est possible que votre application ne puisse pas passer d'appel si un appel est en cours appel d'urgence ou si un appel est en cours dans une autre application mettre en attente avant de passer l'appel.

onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)

Le sous-système de télécommunications appelle cette méthode lorsque votre application appelle la méthode addNewIncomingCall(PhoneAccountHandle, Bundle). pour informer le système d'un nouvel appel entrant dans votre application. Votre application renvoie un nouvelle instance de votre implémentation de Connection (par exemple, Pour en savoir plus, consultez Implémenter la connexion.) pour représenter le nouvel appel entrant. Vous pouvez personnaliser davantage les en effectuant les actions suivantes:

onCreateIncomingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

Le sous-système de télécommunications appelle cette méthode lorsque votre application appelle la méthode addNewIncomingCall(PhoneAccountHandle, Bundle) pour informer Telecom nouvel appel entrant, mais l'appel entrant n'est pas autorisé (pour plus pour plus d'informations, consultez la section Contraintes d'appel). Votre application doit rejetter discrètement l'appel entrant, en publiant éventuellement une notification l'utilisateur de l'appel manqué.

Implémenter la connexion

Votre application doit créer une sous-classe de Connection pour représentent les appels dans votre application. Vous devez remplacer les méthodes suivantes dans votre implémentation:

onShowIncomingCallUi()

Le sous-système de télécommunications appelle cette méthode lorsque vous ajoutez un nouvel appel entrant et votre application doit afficher son UI d'appel entrant.

onCallAudioStateChanged(CallAudioState)

Le sous-système de télécommunications appelle cette méthode pour informer votre application que l'audio actuel la route ou le mode de transport ont changé. Cette méthode est appelée en réponse à la modification du paramètre mode audio avec l'setAudioRoute(int) . Cette méthode peut également être appelée si le système modifie le routage audio. (par exemple, lorsqu'un casque Bluetooth se déconnecte).

onHold()

Le sous-système de télécommunications appelle cette méthode lorsqu'il veut mettre un appel en attente. En réponse à cette demande, votre application doit mettre l'appel en attente, puis appeler la méthode setOnHold() pour informer le système que l'appel est en attente. Le sous-système de télécommunications peut appeler cette méthode lorsque un service d'appel en cours, comme Android Auto, qui affiche votre appel souhaite transmettre la demande d'un utilisateur pour mettre l'appel en attente. Le sous-système de télécommunications appelle également cette méthode si l'utilisateur effectue un appel dans une autre application. Pour plus sur les services des appels en cours, consultez InCallService.

onUnhold()

Le sous-système de télécommunications appelle cette méthode quand il veut reprendre un appel mis en attente. Une fois votre application réactivée l'appel, il doit appeler setActive() pour informer le système que l'appel n'est plus en attente. Le secteur des télécommunications peut appeler cette méthode lorsqu'un service en cours d'appel, comme Android Auto, qui affiche que votre appel souhaite relayer une requête pour reprendre l'appel. Pour Pour en savoir plus sur les services pendant les appels, consultez InCallService.

onAnswer()

Le sous-système de télécommunications appelle cette méthode pour informer à votre application qu'un appel entrant doit être pris en charge. Une fois que votre application a répondu l'appel, il doit appeler setActive() pour informer le système que l'appel a été pris. Le secteur des télécommunications sous-système peut appeler cette méthode lorsque votre application ajoute un appel entrant et Un appel est déjà en cours dans une autre application et ne peut pas être mis en attente. Le sous-système de télécommunications affiche l'UI des appels entrants pour le compte de votre application dans ces instances. Le framework fournit une méthode surchargée qui fournit spécifier l'état vidéo dans lequel répondre à l'appel. Pour plus pour plus d'informations, consultez onAnswer(int).

onReject()

Le sous-système de télécommunications appelle cette méthode lorsqu'il veut rejeter un appel . Une fois que votre application a refusé l'appel, elle doit appeler setDisconnected(DisconnectCause) et spécifier REJECTED comme paramètre. Votre application doit Ensuite, appelez la méthode destroy() pour indiquer au système que l'application a traité l'appel. Le sous-système de télécommunications appelle cette méthode lorsque l'utilisateur a refusé un appel entrant à partir de votre application.

onDisconnect()

Le sous-système de télécommunications appelle cette méthode lorsqu'il souhaite déconnecter un appel. Une fois l'appel terminé, votre application doit appeler la méthode setDisconnected(DisconnectCause) et spécifier LOCAL comme paramètre pour indiquer qu'un de la requête utilisateur a entraîné la déconnexion de l'appel. Votre application doit ensuite appeler la méthode La méthode destroy() permet d'informer le réseau dans lequel l'application a traité l'appel. Le système peut appeler cette méthode Lorsque l'utilisateur a interrompu un appel via un autre service d'appel en cours (par exemple, Android Auto Le système appelle également cette méthode lorsque votre appel doit être pour pouvoir passer un autre appel, par exemple, si l'utilisateur pour passer un appel d'urgence. Pour en savoir plus sur les services pendant les appels, consultez InCallService

Gérer les scénarios d'appel courants

Utiliser l'API ConnectionService dans votre appel consiste à interagir avec les autres classes du android.telecom. d'un package. Les sections suivantes décrivent des scénarios d'appel courants et décrivent comment vos doit utiliser les API pour les gérer.

Répondre aux appels entrants

Le flux de gestion des appels entrants change selon qu'il y a des appels dans d'autres applis ou non. La différence de flux s'explique par le fait que le framework doit établir des contraintes lorsqu'il existe des appels actifs dans d'autres applications pour garantir un environnement stable pour toutes les applications d'appel installées sur l'appareil. Pour plus en savoir plus, consultez la section Contraintes d'appel.

Aucun appel actif dans d'autres applis

Pour répondre aux appels entrants alors qu'il n'y a aucun appel actif dans d'autres applications, suivez procédez comme suit:

  1. Votre application reçoit un nouvel appel entrant à l'aide de ses mécanismes habituels.
  2. Utilisez la méthode addNewIncomingCall(PhoneAccountHandle, Bundle) pour informer le sous-système de télécommunications du nouvel appel entrant.
  3. Le sous-système de télécommunications se lie à l'implémentation ConnectionService de votre application et demande une nouvelle instance de la classe Connection représentant les nouveaux à l'aide de la méthode onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest).
  4. Le sous-système de télécommunications informe votre application qu'elle doit afficher son appel entrant à l'aide de la méthode onShowIncomingCallUi().
  5. Votre application affiche son interface utilisateur entrante à l'aide d'une notification associée à intent plein écran. Pour en savoir plus, consultez onShowIncomingCallUi().
  6. Appelez la méthode setActive() si l'utilisateur accepte l'appel entrant, ou setDisconnected(DisconnectCause) spécifiant REJECTED comme paramètre suivi d'un à la méthode destroy() si l'utilisateur rejette l'appel entrant.

Appels actifs dans d'autres applications qui ne peuvent pas être mis en attente

Pour répondre aux appels entrants alors qu'il y a des appels en cours dans d'autres applis qui ne peuvent pas en attente, procédez comme suit:

  1. Votre application reçoit un nouvel appel entrant à l'aide de ses mécanismes habituels.
  2. Utilisez la méthode addNewIncomingCall(PhoneAccountHandle, Bundle) pour informer le sous-système de télécommunications du nouvel appel entrant.
  3. Le sous-système de télécommunications se lie à l'implémentation ConnectionService de votre application et demande une nouvelle instance de l'objet Connection représentant le nouveau appel entrant à l'aide de la méthode onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest).
  4. Le sous-système "Telecom" affiche l'interface utilisateur de l'appel entrant.
  5. Si l'utilisateur accepte l'appel, le sous-système de télécommunications appelle la méthode onAnswer(). Vous devez appeler la méthode setActive() pour indiquer au que l'appel est maintenant connecté.
  6. Si l'utilisateur refuse l'appel, le sous-système de télécommunications appelle la méthode onReject(). Vous devez appeler la méthode setDisconnected(DisconnectCause) en spécifiant REJECTED comme paramètre, suivi d'une à la méthode destroy().

Passer des appels sortants

Le processus permettant de passer un appel sortant implique de gérer le risque que le ne peut pas être passé en raison des contraintes imposées par le framework des télécommunications. Pour en savoir plus, consultez la section Contraintes d'appel.

Pour passer un appel sortant, procédez comme suit:

  1. L'utilisateur passe un appel sortant dans votre application.
  2. Utilisez la méthode placeCall(Uri, Bundle) pour indiquer au Telecom sur le nouvel appel sortant. Prenez les mesures suivantes : Considérations relatives aux paramètres de méthode: <ph type="x-smartling-placeholder">
      </ph>
    • Le paramètre Uri représente l'adresse à laquelle le auquel l'appel est passé. Pour les numéros de téléphone standards, utilisez l'URI tel: d'un schéma.
    • Le paramètre Bundle vous permet de fournir des informations sur votre application appelante en ajoutant l'objet PhoneAccountHandle de votre application à l'élément EXTRA_PHONE_ACCOUNT_HANDLE supplémentaire. Votre l'application doit fournir l'objet PhoneAccountHandle à chaque appel sortant.
    • Le paramètre Bundle vous permet également de spécifier si le l'appel sortant inclut une vidéo en spécifiant la valeur STATE_BIDIRECTIONAL dans l'extra EXTRA_START_CALL_WITH_VIDEO_STATE. Par défaut, le sous-système "Telecom" achemine les appels vidéo haut-parleur.
  3. Le sous-système de télécommunications se lie au ConnectionService de votre application la mise en œuvre.
  4. Si votre application ne peut pas passer un appel sortant, le sous-système de télécommunications appelle la méthode onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest) pour informer votre application que l'appel ne peut pas être passé à l'heure actuelle. Votre application doit informer l'utilisateur que l'appel ne peut pas être passé.
  5. Si votre application peut passer l'appel sortant, le sous-système de télécommunications appelle l'/le/la onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest) . Votre application doit renvoyer une instance de votre classe Connection pour représenter le nouvel appel sortant. Pour plus d'informations sur les propriétés que vous devez définir dans la connexion, consultez la section Implémenter le service de connexion.
  6. Une fois l'appel sortant connecté, appelez la méthode setActive() pour en informer le sous-système de télécommunications. que l'appel est actif.

Mettre fin à un appel

Pour mettre fin à un appel, procédez comme suit:

  1. Appelez setDisconnected(DisconnectCause) en envoyant LOCAL comme paramètre si l'utilisateur a mis fin à l'appel ou envoyez REMOTE comme paramètre si l'autre partie a mis fin à l'appel.
  2. Appelez la méthode destroy().

Contraintes d'appel

Pour que vos utilisateurs bénéficient d'une expérience d'appel simple et cohérente, applique certaines contraintes pour la gestion des appels sur l'appareil. Pour imaginons que l'utilisateur a installé deux applications appelantes qui implémentent l'API ConnectionService autogérée, FooTalk BarTalk. Dans ce cas, les contraintes suivantes s'appliquent:

  • Sur les appareils exécutant le niveau d'API 27 ou inférieur, une seule application peut gérer une un appel en cours à un moment donné. Cette contrainte signifie que même si un utilisateur appel en cours via l'application FooTalk, l'application BarTalk ne peut ni initier, ni recevoir un nouvel appel.

    Sur les appareils exécutant le niveau d'API 28 ou supérieur, si FooTalk et BarTalk sont tous les deux utilisés déclarer CAPABILITY_SUPPORT_HOLD et CAPABILITY_HOLD autorisations, l'utilisateur peut maintenir plus d'un appel en cours en en passant d'une application à l'autre pour lancer ou répondre à un autre appel.

  • Si l'utilisateur effectue des appels gérés standards (par exemple, en utilisant le l'application Téléphone ou Téléphone intégrée), l'utilisateur ne peut pas participer à des appels depuis les applications d'appel. Cela signifie que si l'utilisateur participe à un appel standard à l'aide de son et ne peuvent pas participer à un appel FooTalk ou BarTalk en même temps.

  • Le sous-système de télécommunications déconnecte les appels de votre application si l'utilisateur compose un appel d'urgence.

  • Votre application ne peut pas recevoir ni passer d'appels lorsque l'utilisateur est en appel d'urgence.

  • Si un appel est en cours dans l'autre application appelante lorsque votre application reçoit appel entrant, y répondre met fin à tous les appels en cours dans la une autre application. Votre application ne doit pas afficher son interface utilisateur habituelle pour les appels entrants. Telecom Framework affiche l'interface utilisateur de l'appel entrant et informe l'utilisateur qui répond au nouvel appel mettra fin à ses appels en cours. Ce signifie que si l'utilisateur participe à un appel FooTalk et que l'application BarTalk reçoit une appel entrant, le framework de télécommunications informe l'utilisateur qu'il dispose d'une nouvelle à un appel BarTalk entrant et que le fait de répondre à l'appel BarTalk met fin à son Appel FooTalk.

Devenir l'application de téléphone par défaut

L'application Téléphone/Téléphone par défaut est celle qui fournit l'interface utilisateur en cours d'appel lorsque l'appareil est pendant un appel. Elle permet également à l'utilisateur d'initier des appels et de consulter l'historique des appels. sur leur appareil. Un appareil est fourni avec une application de téléphonie/téléphone par défaut fournie par le système. L'utilisateur peut choisir une seule application pour assumer ce rôle à partir de l'application système. Une application qui souhaite remplir ce rôle utilise RoleManager pour demander qu'il remplisse Rôle RoleManager.ROLE_DIALER.

L'application pour téléphone par défaut fournit une interface utilisateur pendant un appel. pas en mode Voiture (par exemple, UiModeManager#getCurrentModeType() n'est pas Configuration.UI_MODE_TYPE_CAR).

Pour remplir le rôle RoleManager.ROLE_DIALER, une application doit répondre à un d'exigences:

  • Il doit gérer l'intent Intent#ACTION_DIAL. Cela signifie que l'application doit fournir un clavier numérique UI permettant à l'utilisateur d'initier des appels sortants.
  • Il doit implémenter entièrement l'API InCallService et fournir un appel entrant et une UI d'appel en cours.

Remarque: Si l'application qui remplit les RoleManager.ROLE_DIALER renvoie une null InCallService pendant la liaison, le framework de télécommunications tombe automatiquement à l'utilisation de l'application de clavier préchargée sur l'appareil. Le système affiche une notification l'utilisateur pour lui faire savoir que son appel a été poursuivi en utilisant l'application téléphonique préchargée. Votre L'application ne doit jamais renvoyer de liaison null. cela signifie qu'elle ne respecte pas les exigences de RoleManager.ROLE_DIALER.

Remarque: Si votre application remplit RoleManager.ROLE_DIALER et apporte des modifications à qui l'empêchent de remplir les exigences de ce rôle, RoleManager supprimera automatiquement votre application du rôle et se fermera votre application. Par exemple, si vous utilisez PackageManager.setComponentEnabledSetting(ComponentName, int, int) jusqu'à désactiver de manière programmatique les InCallService déclarés par votre application dans son fichier manifeste, votre application ne rempliront plus les exigences RoleManager.ROLE_DIALER

Le clavier préchargé est TOUJOURS utilisé lorsque l'utilisateur passe un appel d'urgence, même si votre l'application remplit le rôle RoleManager.ROLE_DIALER. Pour garantir une expérience optimale lors d'un appel d'urgence, le clavier par défaut doit TOUJOURS utiliser TelecomManager.placeCall(Uri, Bundle) pour passer des appels (y compris appels d'urgence). Cela garantit que la plate-forme est en mesure de vérifier que la requête provient de le clavier par défaut. Si une application de téléphonie non préchargée utilise Intent#ACTION_CALL pour placer un appel d'urgence, il sera transmis à l'application de téléphonie préchargée à l'aide de Intent#ACTION_DIAL pour confirmation. l'expérience utilisateur n'est pas optimale.

Vous trouverez ci-dessous un exemple d'enregistrement de fichier manifeste pour un InCallService. Les métadonnées TelecomManager#METADATA_IN_CALL_SERVICE_UI indique que cet élément L'implémentation de InCallService vise à remplacer l'interface utilisateur intégrée aux appels vidéo. Les métadonnées TelecomManager#METADATA_IN_CALL_SERVICE_RINGING indiquent que cette InCallService émettra la sonnerie pour les appels entrants. Voir ci-dessous pour en savoir plus sur l'affichage de l'appel entrant UI et lecture de la sonnerie dans votre application.

 <service android:name="your.package.YourInCallServiceImplementation"
          android:permission="android.permission.BIND_INCALL_SERVICE"
          android:exported="true">
      <meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" />
      <meta-data android:name="android.telecom.IN_CALL_SERVICE_RINGING"
          android:value="true" />
      <intent-filter>
          <action android:name="android.telecom.InCallService"/>
      </intent-filter>
 </service>

Remarque: Vous ne devez PAS indiquer votre InCallService avec l'attribut android:exported="false"; cela peut entraîner l'échec de la liaison avec votre implémentation pendant les appels.

En plus d'implémenter l'API InCallService, vous devez également déclarer une activité dans Votre fichier manifeste, qui gère l'intent Intent#ACTION_DIAL. L'exemple ci-dessous illustre comment procéder:

 <activity android:name="your.package.YourDialerActivity"
           android:label="@string/yourDialerActivityLabel">
      <intent-filter>
           <action android:name="android.intent.action.DIAL" />
           <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
      <intent-filter>
           <action android:name="android.intent.action.DIAL" />
           <category android:name="android.intent.category.DEFAULT" />
           <data android:scheme="tel" />
      </intent-filter>
 </activity>

Lorsqu'un utilisateur installe votre application et l'exécute pour la première fois, vous devez utiliser la méthode RoleManager pour inviter l'utilisateur à savoir s'il souhaite que votre appli devenir la nouvelle application par défaut pour téléphone.

Le code ci-dessous montre comment votre application peut demander à devenir l'application de téléphone/d'appel téléphonique par défaut:

 private static final int REQUEST_ID = 1;

 public void requestRole() {
     RoleManager roleManager = (RoleManager) getSystemService(ROLE_SERVICE);
     Intent intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_DIALER);
     startActivityForResult(intent, REQUEST_ID);
 }

 public void onActivityResult(int requestCode, int resultCode, Intent data) {
     if (requestCode == REQUEST_ID) {
         if (resultCode == android.app.Activity.RESULT_OK) {
             // Your app is now the default dialer app
         } else {
             // Your app is not the default dialer app
         }
     }
 }

Accès à InCallService pour les accessoires connectés

<ph type="x-smartling-placeholder">
    </ph> Si votre application est une application associée tierce et souhaite accéder aux API InCallService, quels pourrait faire sont:

    1. Déclarer l'autorisation MANAGE_ONGOING_CALLS dans votre fichier manifeste
    2. Associer un accessoire connecté physique via la CompanionDeviceManager en tant qu'application associée. Voir: https://developer.android.com/guide/topics/connectivity/companion-device-pairing
    3. Implémenter ce service InCallService avec l'autorisation BIND_INCALL_SERVICE

Affichage de la notification d'appel entrant

Lorsque votre application reçoit un nouvel appel entrant via InCallService#onCallAdded(Call), il est chargé d'afficher une UI d'appel entrant pour l'appel entrant. Pour ce faire, il doit utiliser API NotificationManager pour publier une nouvelle notification d'appel entrant.

Lorsque votre application déclare les métadonnées TelecomManager#METADATA_IN_CALL_SERVICE_RINGING, elle est responsable de la diffusion de la sonnerie lors des appels entrants. Votre application doit créer NotificationChannel, qui spécifie la sonnerie souhaitée. Exemple :

 NotificationChannel channel = new NotificationChannel(YOUR_CHANNEL_ID, "Incoming Calls",
          NotificationManager.IMPORTANCE_MAX);
 // other channel setup stuff goes here.

 // We'll use the default system ringtone for our incoming call notification channel.  You can
 // use your own audio resource here.
 Uri ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
 channel.setSound(ringtoneUri, new AudioAttributes.Builder()
          // Setting the AudioAttributes is important as it identifies the purpose of your
          // notification sound.
          .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
      .build());

 NotificationManager mgr = getSystemService(NotificationManager.class);
 mgr.createNotificationChannel(channel);

Lorsque votre application reçoit un nouvel appel entrant, elle crée un Notification pour le appel entrant et l'associe au canal de notification des appels entrants. Vous pouvez spécifier un PendingIntent sur la notification pour lancer le mode plein écran appel entrant. Le gestionnaire des notifications affiche vos notifications sous la forme une notification prioritaire si l'utilisateur est en train d'utiliser le téléphone. Lorsque l'utilisateur n'utilise pas téléphone, c'est l'interface utilisateur plein écran des appels entrants qui est utilisée à la place. Exemple :

 // Create an intent which triggers your fullscreen incoming call user interface.
 Intent intent = new Intent(Intent.ACTION_MAIN, null);
 intent.setFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION | Intent.FLAG_ACTIVITY_NEW_TASK);
 intent.setClass(context, YourIncomingCallActivity.class);
 PendingIntent pendingIntent = PendingIntent.getActivity(context, 1, intent, PendingIntent.FLAG_MUTABLE_UNAUDITED);
 // Build the notification as an ongoing high priority item; this ensures it will show as
 // a heads up notification which slides down over top of the current content.
 final Notification.Builder builder = new Notification.Builder(context);
 builder.setOngoing(true);
 builder.setPriority(Notification.PRIORITY_HIGH);
 // Set notification content intent to take user to the fullscreen UI if user taps on the
 // notification body.
 builder.setContentIntent(pendingIntent);
 // Set full screen intent to trigger display of the fullscreen UI when the notification
 // manager deems it appropriate.
 builder.setFullScreenIntent(pendingIntent, true);
 // Setup notification content.
 builder.setSmallIcon( yourIconResourceId );
 builder.setContentTitle("Your notification title");
 builder.setContentText("Your notification content.");
 // Use builder.addAction(..) to add buttons to answer or reject the call.
 NotificationManager notificationManager = mContext.getSystemService(
     NotificationManager.class);
 notificationManager.notify(YOUR_CHANNEL_ID, YOUR_TAG, YOUR_ID, builder.build());
```