Standard-Telefonanwendung erstellen

Mit einer Standard-Telefonanwendung kann das Android Telecom-Framework Ihre Anwendung über den Anrufstatus informieren. Dazu wird mithilfe des Rollenmanagers und des Anrufdienstes ein Ersatz für die Standard-Telefon-App auf einem Android-Gerät erstellt und die InCallService API implementiert. Ihre Implementierung muss die folgenden Anforderungen erfüllen:

Er darf keine Anruffunktion haben und darf ausschließlich aus der Benutzeroberfläche für Anrufe bestehen. Sie muss alle Anrufe verarbeiten, die dem Telekommunikations-Framework bekannt sind, und keine Mutmaßungen über die Art der Anrufe anstellen. Beispielsweise darf sie nicht davon ausgehen, dass es sich bei Anrufen um SIM-basierte Telefonieanrufe handelt, und keine Anrufbeschränkungen implementieren, die auf einem einzelnen ConnectionService basieren, wie z. B. Erzwingung von Telefonieeinschränkungen für Videoanrufe.

Mit einer Anruf-App können Nutzer Audio- und Videoanrufe auf ihrem Gerät . Anruf-Apps nutzen für Anrufe ihre eigene Benutzeroberfläche Standardoberfläche der Telefon App, wie im folgenden Screenshot dargestellt.

Beispiel für eine Anruf-App
Beispiel für eine aufrufende App mit eigener Benutzeroberfläche

Das Android-Framework enthält das Paket android.telecom, das enthält Klassen, die Ihnen dabei helfen, eine Anruf-App für den Framework. Wenn Sie Ihre App nach dem Telekommunikations-Framework entwickeln, die folgenden Vorteile:

  • Ihre App funktioniert ordnungsgemäß mit dem nativen Telekommunikationssubsystem im .
  • Ihre App funktioniert ordnungsgemäß mit anderen Anruf-Apps, die ebenfalls die des Frameworks.
  • Das Framework unterstützt Ihre App bei der Verwaltung von Audio- und Videorouting.
  • Mithilfe des Frameworks kann Ihre App feststellen, ob die Aufrufe im Mittelpunkt stehen.

Manifestdeklarationen und Berechtigungen

Deklariere in deinem App-Manifest, dass deine App die MANAGE_OWN_CALLS wie im folgenden Beispiel gezeigt:

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

Weitere Informationen zum Deklarieren von App-Berechtigungen findest du unter Berechtigungen:

Sie müssen einen Dienst deklarieren, der die Klasse angibt, die das Tag ConnectionService Kurs in deiner App. Telekommunikation Subsystem erfordert, dass der Dienst die Berechtigung BIND_TELECOM_CONNECTION_SERVICE für sich daran binden. Das folgende Beispiel zeigt, wie der Dienst in App-Manifest ein:

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

Weitere Informationen zum Deklarieren von App-Komponenten, einschließlich Diensten, finden Sie unter App-Komponenten:

Verbindungsdienst implementieren

Die aufrufende App muss eine Implementierung der ConnectionService-Klasse enthalten, an die das Telekommunikationssubsystem gebunden werden kann. Ihre ConnectionService-Implementierung sollte die folgenden Methoden verwenden:

onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)

Das Telekommunikationssubsystem ruft diese Methode als Reaktion auf Deine App ruft placeCall(Uri, Bundle) auf , um einen neuen ausgehenden Anruf zu erstellen. Ihre App gibt eine neue Instanz der Implementierung der Connection-Klasse zurück. Weitere Informationen finden Sie unter Implementieren Sie die Verbindung), um die neue ausgehender Anruf. Sie können die ausgehende Verbindung weiter anpassen, indem Sie die folgenden Aktionen ausführen:

onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

Das Telekommunikationssubsystem ruft diese Methode auf, wenn Ihre App die Methode placeCall(Uri, Bundle) aufruft und der ausgehende Anruf nicht platziert werden. Als Reaktion auf diese Situation sollte Ihre App den Nutzer (für z. B. durch ein Benachrichtigungsfeld oder einen Toast), dass der ausgehende Anruf nicht platziert. Deine App kann möglicherweise keinen Anruf starten, wenn ein Anruf aktiv ist oder wenn ein Anruf in einer anderen App aktiv ist, bevor du einen Anruf tätigst.

onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)

Das Telekommunikationssubsystem ruft diese Methode auf, wenn Ihre App die Methode addNewIncomingCall(PhoneAccountHandle, Bundle) aufruft. um das System über einen neuen eingehenden Anruf in deiner App zu informieren. Ihre App gibt eine neue Instanz der Connection-Implementierung (für Weitere Informationen finden Sie unter Verbindung implementieren.) für den neuen eingehenden Anruf. Sie können eingehende Anfragen Verbindung herstellen, indem Sie die folgenden Aktionen ausführen:

onCreateIncomingConnectionFailed(PhoneAccountHandle, ConnectionRequest)

Das Telekommunikationssubsystem ruft diese Methode auf, wenn Ihre App die Methode addNewIncomingCall(PhoneAccountHandle, Bundle) aufruft, um die Telekommunikation über eingehenden Anruf an, der eingehende Anruf ist jedoch nicht erlaubt (weitere finden Sie unter Einschränkungen aufrufen. Ihre App sollte Eingehenden Anruf lautlos ablehnen und optional eine Benachrichtigung den Nutzer des verpassten Anrufs.

Verbindung implementieren

Ihre Anwendung sollte eine abgeleitete Klasse von Connection erstellen, um die Anrufe in Ihrer App darstellen. Sie sollten die folgenden Methoden in Ihre Implementierung:

onShowIncomingCallUi()

Das Telekommunikationssubsystem ruft diese Methode auf, wenn Sie einen neuen eingehenden Anruf hinzufügen und sollte die Benutzeroberfläche für eingehende Anrufe angezeigt werden.

onCallAudioStateChanged(CallAudioState)

Das Telekommunikationssubsystem ruft diese Methode auf, um Ihrer App mitzuteilen, die Route oder den Modus geändert hat. Dieser wird aufgerufen, wenn Ihre App die Audiomodus mit der setAudioRoute(int) . Diese Methode kann auch aufgerufen werden, wenn das System die Audioroute ändert. z. B. wenn die Verbindung zu einem Bluetooth-Headset getrennt wird.

onHold()

Das Telekommunikationssubsystem ruft diese Methode auf, wenn ein Anruf gehalten werden soll. Als Antwort auf diese Anfrage sollte Ihre App den Aufruf halten und dann die Methode setOnHold()-Methode, um das System zu informieren dass der Anruf gehalten wird. Das Telekommunikationssubsystem kann diese Methode aufrufen, ein laufender Dienst wie Android Auto, der anzeigt, dass Ihr Anruf eine Nutzeranfrage weiterleiten, um den Anruf zu halten. Das Telekommunikationssubsystem wenn der Nutzer einen Aufruf in einer anderen App aktiviert. Weitere Informationen Informationen zu Diensten während eines Anrufs finden Sie unter InCallService.

onUnhold()

Das Telekommunikationssubsystem ruft diese Methode auf, Ein gehaltener Anruf wird fortgesetzt. Sobald Ihre App fortgesetzt wird des Aufrufs sollte die setActive() aufgerufen werden. , um dem System mitzuteilen, dass der Anruf nicht mehr gehalten wird. Telekommunikation kann diese Methode aufgerufen werden, wenn ein Anrufdienst wie Android Auto wird angezeigt, dass Ihr Anruf eine Anfrage zum Fortsetzen des Anrufs weiterleiten möchte. Für Weitere Informationen zu Diensten während eines Anrufs finden Sie unter InCallService.

onAnswer()

Das Telekommunikationssubsystem ruft diese Methode auf, App, dass ein eingehender Anruf angenommen wird. Sobald Ihre App eine Antwort des Aufrufs sollte die setActive() aufgerufen werden. , um dem System mitzuteilen, dass der Anruf angenommen wurde. Telekommunikation kann diese Methode vom Subsystem aufgerufen werden, wenn Ihre App einen neuen eingehenden Anruf hinzufügt Es gibt bereits einen Anruf in einer anderen App, der nicht gehalten werden kann. Das Telekommunikationssubsystem zeigt die UI für eingehende Anrufe im Namen Ihrer App in diese Instanzen. Das Framework bietet eine überlastete Methode, -Unterstützung, um den Videostatus anzugeben, in dem der Anruf entgegengenommen werden soll. Weitere Informationen finden Sie unter onAnswer(int).

onReject()

Das Telekommunikationssubsystem ruft diese Methode auf, wenn ein anrufen. Sobald deine App den Aufruf abgelehnt hat, sollte sie setDisconnected(DisconnectCause) aufrufen und REJECTED als Parameter angeben. Ihre App sollte Rufen Sie dann die Methode destroy() auf, System, dass die App den Anruf verarbeitet hat. Das Telekommunikationssubsystem ruft wenn der Nutzer einen eingehenden Anruf von Ihrer App abgelehnt hat.

onDisconnect()

Das Telekommunikationssubsystem ruft diese Methode auf, wenn es einen Anruf trennen möchte. Nach Beendigung des Aufrufs sollte Ihre App die Methode setDisconnected(DisconnectCause) aufrufen und LOCAL als Parameter angeben, um anzugeben, dass ein Nutzeranfrage hat dazu geführt, dass der Anruf unterbrochen wurde. Ihre App sollte dann die Methode destroy()-Methode zur Information der Telekommunikationsbranche Subsystem, in dem die App den Aufruf verarbeitet hat. Das System kann diese Methode aufrufen, Der Nutzer hat einen Anruf über einen anderen während des Anrufs getätigten Dienst getrennt, z. B. Android Auto Das System ruft diese Methode auch auf, wenn Ihr Aufruf getrennt, damit andere Anrufe getätigt werden können, z. B. wenn der Nutzer um einen Notruf abzusetzen. Weitere Informationen zu Diensten während eines Anrufs finden Sie unter InCallService

Häufige Anrufszenarien bewältigen

ConnectionService API in Ihrem Aufruf verwenden umfasst die Interaktion mit den anderen Klassen im android.telecom Paket. In den folgenden Abschnitten werden gängige Anrufszenarien beschrieben und Sie erfahren, App sollte die APIs für ihre Verarbeitung verwenden.

Eingehende Anrufe annehmen

Der Ablauf zur Verarbeitung eingehender Anrufe ändert, ob Anrufe in anderen Apps eingehen oder nicht. Der Grund für die unterschiedlichen Abläufe ist, dass das Telekommunikations-Framework müssen einige Einschränkungen festgelegt werden, wenn es in anderen Apps aktive Aufrufe für um eine stabile Umgebung für alle Anruf-Apps auf dem Gerät zu gewährleisten. Weitere Informationen Weitere Informationen finden Sie unter Aufrufeinschränkungen.

Keine aktiven Anrufe in anderen Apps

Um eingehende Anrufe anzunehmen, wenn keine Anrufe in anderen Apps aktiv sind, folge diese Schritte:

  1. Ihre App empfängt einen neuen eingehenden Anruf wie gewohnt.
  2. Verwenden Sie die Methode addNewIncomingCall(PhoneAccountHandle, Bundle), um das Telekommunikationssubsystem über den neuen eingehenden Anruf zu informieren.
  3. Das Telekommunikations-Subsystem wird an die ConnectionService-Implementierung Ihrer Anwendung gebunden und fordert eine neue Instanz an der Klasse Connection, die die neuen eingehenden mit der Methode onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest) aufrufen.
  4. Das Subsystem des Telekommunikationsanbieters informiert Ihre App darüber, dass eingehende Anrufe angezeigt werden sollen mithilfe der Methode onShowIncomingCallUi().
  5. Ihre App zeigt die eingehende UI in Form einer Benachrichtigung mit einem zugehörigen Full-Screen Intent. Weitere Informationen findest du unter onShowIncomingCallUi().
  6. Rufen Sie die Methode setActive() auf, wenn der Nutzer akzeptiert den eingehenden Anruf oder setDisconnected(DisconnectCause) und gibt REJECTED als Parameter an, gefolgt von einem die Methode destroy() aufrufen, wenn der Nutzer lehnt den eingehenden Anruf ab.

Aktive Anrufe in anderen Apps, die nicht gehalten werden können

Zum Annehmen eingehender Anrufe, wenn in anderen Apps aktive Anrufe eingehen, die das nicht können auf „Hold“ gesetzt werden, gehen Sie so vor:

  1. Ihre App empfängt einen neuen eingehenden Anruf wie gewohnt.
  2. Verwenden Sie die Methode addNewIncomingCall(PhoneAccountHandle, Bundle), um das Telekommunikationssubsystem über den neuen eingehenden Anruf zu informieren.
  3. Das Telekommunikations-Subsystem wird an die ConnectionService-Implementierung Ihrer Anwendung gebunden und fordert eine neue Instanz an des Connection-Objekts, das das neue einen eingehenden Anruf mit der Methode onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest) an.
  4. Das Subsystem des Telekommunikationsanbieters zeigt die Benutzeroberfläche für eingehende Anrufe an.
  5. Wenn der Nutzer den Anruf annimmt, ruft das Telekommunikationssubsystem die Methode onAnswer() auf. Rufen Sie die Methode setActive() auf, um dem Telefonunternehmen mitzuteilen, Subsystem, mit dem der Anruf jetzt verbunden ist.
  6. Wenn der Nutzer den Anruf ablehnt, ruft das Telekommunikationssubsystem die Methode onReject() auf. Rufen Sie die Methode setDisconnected(DisconnectCause) auf und geben Sie REJECTED als Parameter an, gefolgt von einem die Methode destroy() aufrufen.

Ausgehende Anrufe tätigen

Beim Tätigen eines ausgehenden Anrufs muss die Möglichkeit berücksichtigt werden, kann aufgrund von Einschränkungen durch das Telekommunikations-Framework nicht getätigt werden. Weitere Informationen finden Sie unter Aufrufeinschränkungen.

So tätigen Sie einen Anruf:

  1. Der Nutzer initiiert in Ihrer App einen ausgehenden Anruf.
  2. Verwenden Sie die Methode placeCall(Uri, Bundle), um den Subsystem des Telekommunikationsanbieters über den neuen ausgehenden Anruf. Nehmen Sie Folgendes: Überlegungen zu den Methodenparametern: <ph type="x-smartling-placeholder">
      </ph>
    • Der Parameter Uri steht für die Adresse, an der der an den der Anruf erfolgt. Verwenden Sie für normale Telefonnummern den URI tel:. .
    • Mit dem Parameter Bundle können Sie Informationen zu deiner aufrufenden App, indem du das PhoneAccountHandle-Objekt deiner App zum EXTRA_PHONE_ACCOUNT_HANDLE-Extra hinzufügst. Ihr Die App muss für jeden ausgehenden Anruf das PhoneAccountHandle-Objekt bereitstellen.
    • Mit dem Parameter Bundle können Sie auch festlegen, Der ausgehende Anruf enthält Video, indem der Wert STATE_BIDIRECTIONAL in der zusätzlichen EXTRA_START_CALL_WITH_VIDEO_STATE angegeben wird. Beachten Sie, dass das Telekommunikationssubsystem Videoanrufe standardmäßig an den Freisprechfunktion.
  3. Das Subsystem des Telekommunikationsanbieters wird an die ConnectionService Ihrer App gebunden Implementierung.
  4. Wenn Ihre App keine ausgehenden Anrufe ermöglicht, ruft das Subsystem des Telekommunikationsanbieters die Methode onCreateOutgoingConnectionFailed(PhoneAccountHandle, ConnectionRequest), um Informieren Sie die App darüber, dass der Anruf zum aktuellen Zeitpunkt nicht möglich ist. Ihre App sollte den Nutzer darüber informieren, dass der Anruf nicht getätigt werden kann.
  5. Wenn deine App in der Lage ist, ausgehende Anrufe zu tätigen, ruft das Subsystem des Telekommunikationsanbieters onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest) . Ihre App sollte eine Instanz Ihrer Connection-Klasse zurückgeben, die den neuen ausgehenden Anruf darstellt. Für weitere Informationen zu den Eigenschaften, die Sie in der Verbindung festlegen sollten, Siehe Verbindungsdienst implementieren.
  6. Wenn der ausgehende Anruf verbunden ist, rufen Sie die Methode setActive() auf, um das Subsystem des Telekommunikationsanbieters zu informieren dass der Anruf aktiv ist.

Anruf beenden

So beenden Sie einen Anruf:

  1. Rufen Sie setDisconnected(DisconnectCause) auf, das LOCAL als Parameter sendet, wenn der Nutzer beendet den Anruf oder sende REMOTE als Parameter verwenden, wenn die andere Partei den Aufruf beendet hat.
  2. Rufen Sie die Methode destroy() auf.

Aufrufeinschränkungen

Um den Nutzern ein einheitliches und einfaches Telefonieren zu ermöglichen, -Framework erzwingt einige Einschränkungen für die Anrufverwaltung auf dem Gerät. Für Angenommen, der Nutzer hat zwei aufrufende Apps installiert, die selbstverwaltete ConnectionService API, FooTalk und BarTalk: In diesem Fall gelten die folgenden Einschränkungen:

  • Auf Geräten mit API-Level 27 oder niedriger kann nur eine App laufenden Anrufs zu einem bestimmten Zeitpunkt. Diese Einschränkung bedeutet, dass ein Nutzer aktuellen Anruf über die FooTalk-App nicht aktiv ist, kann die BarTalk-App keinen einen neuen Anruf starten.

    Auf Geräten mit API-Level 28 oder höher, wenn sowohl FooTalk als auch BarTalk deklarieren CAPABILITY_SUPPORT_HOLD und CAPABILITY_HOLD hat, kann der Nutzer mehrere aktive Anrufe um zwischen den Apps zu wechseln, um einen weiteren Anruf zu starten oder anzunehmen.

  • Wenn der Nutzer regelmäßig verwaltete Aufrufe durchführt (z. B. die Verwendung des integrierten Telefon- oder Telefon-App), kann der Nutzer nicht an Anrufen teilnehmen, die von Apps für Anrufe. Wenn ein Nutzer also an einem normalen Anruf teilnimmt und Mobilfunkanbieter verwenden, können sie nicht gleichzeitig an einem FooTalk- oder BarTalk-Anruf teilnehmen.

  • Das Telekommunikationssubsystem trennt die Anrufe Ihrer App, wenn der Nutzer eine Notruf.

  • Ihre App kann keine Anrufe empfangen oder tätigen, während sich der Nutzer in einem Notruf befindet.

  • Wenn in einer anderen App ein Anruf eingeht, wenn Ihre App einen Anruf empfängt einen eingehenden Anruf annehmen, werden alle laufenden Anrufe im in einer anderen App. Ihre App sollte nicht die normale Benutzeroberfläche für eingehende Anrufe anzeigen. Das Telekommunikations-Framework zeigt die Benutzeroberfläche für eingehende Anrufe an und informiert Der Nutzer, der den neuen Anruf annimmt, beendet seinen aktuellen Anruf bzw. seine laufenden Anrufe. Dieses Wenn der Nutzer an einem FooTalk-Anruf teilnimmt und die BarTalk-App eine einen eingehenden Anruf an, informiert das Telekommunikations-Framework den Nutzer, dass er eingehenden BarTalk-Anrufs an und durch den Annehmen des BarTalk-Anrufs wird die FooTalk-Anruf.

Wird zur Standard-Telefon-App

Die Standard-Telefon-/Telefon-App stellt die Benutzeroberfläche für laufende Anrufe bereit, während das Gerät eingeschaltet ist. während eines Anrufs. Darüber hinaus kann der Nutzer Anrufe tätigen und den Verlauf der Anrufe einsehen. auf ihrem Gerät. Ein Gerät ist mit einer vom System bereitgestellten Standard-Telefon-/Telefon-App ausgestattet. Der Nutzer eine einzelne App auswählen, die diese Rolle von der System-App übernimmt. Eine App, die für diese Rolle die RoleManager verwendet, um zu beantragen, dass Rolle RoleManager.ROLE_DIALER.

Die Standard-Telefon-App bietet eine Benutzeroberfläche, während das Gerät während eines Anrufs telefoniert. nicht im Automodus (d.h. UiModeManager#getCurrentModeType() ist nicht Configuration.UI_MODE_TYPE_CAR).

Um die Rolle RoleManager.ROLE_DIALER zu erhalten, muss eine App eine Anforderungen:

  • Er muss den Intent Intent#ACTION_DIAL verarbeiten. Das bedeutet, dass die App eine Wähltastatur-Benutzeroberfläche, über die Nutzer ausgehende Anrufe starten können.
  • Sie muss die InCallService API vollständig implementieren und sowohl einen eingehenden Aufruf als auch und eine UI für laufende Anrufe.

Hinweis: Wenn die App, die das RoleManager.ROLE_DIALER-Objekt ausfüllt, eine Fehlermeldung null InCallService während der Bindung, wird das Telekommunikations-Framework automatisch verworfen wieder die Telefon-App verwenden, die auf dem Gerät vorinstalliert war. Das System zeigt eine Benachrichtigung an Der Nutzer teilt ihm mit, dass sein Anruf mit der vorinstallierten Telefon-App fortgesetzt wurde. Ihr App sollte niemals eine null-Bindung zurückgeben. bedeutet dies, dass die Anforderungen von RoleManager.ROLE_DIALER.

Hinweis: Wenn deine App RoleManager.ROLE_DIALER füllt und Änderungen vornimmt, die dazu führen, dass sie die Anforderungen dieser Rolle nicht mehr erfüllt, RoleManager entfernt deine App automatisch aus der Rolle und schließt sie für Ihre App. Wenn Sie beispielsweise PackageManager.setComponentEnabledSetting(ComponentName, int, int) bis die InCallService, die Ihre App in ihrem Manifest deklariert, programmatisch deaktivieren, nicht mehr die erwarteten Anforderungen RoleManager.ROLE_DIALER

Die vorab geladene Telefon App wird IMMER verwendet, wenn der Nutzer einen Notruf absetzt, selbst wenn Ihr App die Rolle RoleManager.ROLE_DIALER hat. Um eine optimale beim Absetzen eines Notrufs verwendet, sollte das Standard-Telefon IMMER TelecomManager.placeCall(Uri, Bundle) zum Tätigen von Anrufen (einschließlich Notrufe). So kann die Plattform prüfen, ob die Anfrage von Standard-Telefon. Wenn eine nicht vorinstallierte Telefon-App Intent#ACTION_CALL verwendet, um eine Notruf, wird dieser über Intent#ACTION_DIAL an die vorinstallierte Telefon-App gesendet. zur Bestätigung. ist dies eine suboptimale User Experience.

Unten siehst du ein Beispiel für die Registrierung eines Manifests für eine InCallService. Die Metadaten TelecomManager#METADATA_IN_CALL_SERVICE_UI gibt an, dass diese Bei der Implementierung von InCallService soll die integrierte Benutzeroberfläche für Aufrufe ersetzt werden. Die Metadaten TelecomManager#METADATA_IN_CALL_SERVICE_RINGING geben an, dass dies InCallService spielt den Klingelton für eingehende Anrufe ab. Weitere Informationen finden Sie unter Weitere Informationen zum Anzeigen eingehender Anrufe Benutzeroberfläche und die Wiedergabe des Klingeltons in deiner App

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

Hinweis: Kennzeichnen Sie Ihre InCallService NICHT mit dem Attribut android:exported="false"; Dies kann dazu führen, dass die Bindung an Ihre Implementierung fehlschlägt. während eines Anrufs.

Zusätzlich zur Implementierung der InCallService API müssen Sie auch eine Aktivität in Ihr Manifest, das den Intent#ACTION_DIAL-Intent verarbeitet. Im folgenden Beispiel sehen Sie, wie das funktioniert:

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

Wenn ein Nutzer Ihre Anwendung installiert und zum ersten Mal ausführt, sollten Sie die Methode RoleManager, um den Nutzer zu fragen, ob deine App diese Aktion ausführen soll die neue Standard-Telefon-App.

Der folgende Code zeigt, wie Ihre App anfordern kann, die Standard-Telefon-/Telefon-App zu werden:

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

Zugriff auf InCallService für Wearable-Geräte

<ph type="x-smartling-placeholder">
    </ph> Wenn es sich bei deiner App um eine Companion-App eines Drittanbieters handelt und du auf InCallService APIs zugreifen möchtest, welche Informationen Folgendes können:

    1. Deklariere die Berechtigung MANAGE_ONGOING_CALLS in deinem Manifest
    2. Verknüpfung mit einem physischen Wearable über das CompanionDeviceManager API als Companion-App. Weitere Informationen: https://developer.android.com/guide/topics/connectivity/Companion-device-pairing
    3. InCallService mit Berechtigung BIND_INCALL_SERVICE implementieren

Benachrichtigung über eingehenden Anruf anzeigen

Wenn in deiner App über InCallService#onCallAdded(Call) ein neuer eingehender Anruf eingeht, ist das ist für die Anzeige eines eingehenden Anrufs bei einem eingehenden Anruf verantwortlich. Dies sollte mithilfe der NotificationManager APIs zum Posten einer Benachrichtigung über einen neuen eingehenden Anruf.

Wenn in deiner App die Metadaten TelecomManager#METADATA_IN_CALL_SERVICE_RINGING deklariert sind, werden ist für die Wiedergabe des Klingeltons bei eingehenden Anrufen verantwortlich. Ihre App sollte eine NotificationChannel für den gewünschten Klingelton. Beispiel:

 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);

Wenn deine App einen neuen eingehenden Anruf empfängt, wird ein Notification für das eingehenden Anrufs an und ordnet ihn Ihrem Benachrichtigungskanal zu eingehenden Anrufen zu. Sie können eine PendingIntent für die Benachrichtigung, mit der der Vollbildmodus gestartet wird UI für eingehende Anrufe Im Notification Manager-Framework wird Ihre Benachrichtigung als eine Warnmeldung, wenn der Nutzer das Smartphone aktiv verwendet. Wenn der Nutzer die Smartphone verwenden, wird stattdessen die Benutzeroberfläche für eingehende Anrufe im Vollbildmodus verwendet. Beispiel:

 // 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());
```