Core-Telecom

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Die Core-Telecom-Bibliothek vereinfacht die Integration Ihrer anrufenden Anwendung in die Android-Plattform, da sie eine robuste und konsistente Reihe von APIs bietet.

Wenn Sie sich praktische Implementierungen ansehen möchten, finden Sie auf GitHub Beispielanwendungen:

• Leichte Beispiel-App: Ein minimales Beispiel, das die Verwendung der Core-Telecom API veranschaulicht. Ideal, um sich schnell grundlegende Konzepte anzueignen.
• Umfassende Beispiel-App (vom Core-Telecom-Team entwickelt): Eine funktionsreichere Anwendung, die erweiterte Telekommunikationsfunktionen und Best Practices zeigt. Dies ist eine gute Ressource, um komplexe Integrationsszenarien zu verstehen.

Core-Telecom einrichten

Fügen Sie der Datei build.gradle Ihrer App die Abhängigkeit androidx.core:core-telecom hinzu:

dependencies {
    implementation ("androidx.core:core-telecom:1.0.0")
}

Deklarieren Sie die Berechtigung MANAGE_OWN_CALLS in Ihrem AndroidManifest.xml:

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

App registrieren

Registrieren Sie Ihre Anruf-App mit CallsManager bei Android, um dem System Anrufe hinzuzufügen. Geben Sie bei der Registrierung die Funktionen Ihrer App an (z. B. Audio- und Videounterstützung):

val callsManager = CallsManager(context)

val capabilities: @CallsManager.Companion.Capability Int =
    (CallsManager.CAPABILITY_BASELINE or
          CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING)

callsManager.registerAppWithTelecom(capabilities)

Anrufverwaltung

Verwenden Sie Core-Telecom APIs, um einen Anrufzyklus zu erstellen und zu verwalten.

Anruf erstellen

Das CallAttributesCompat-Objekt definiert die Eigenschaften eines eindeutigen Anrufs, der die folgenden Merkmale haben kann:

• displayName: Name des Anrufers.
• address: Anrufadresse (z. B. Telefonnummer, Konferenzlink)
• direction: Eingehend oder ausgehend.
• callType: Audio oder Video.
• callCapabilities: Unterstützt Weiterleiten und Halten.

Hier ein Beispiel für das Erstellen eines eingehenden Anrufs:

fun createIncomingCallAttributes(
    callerName: String,
    callerNumber: String,
    isVideoCall: Boolean): CallAttributesCompat {
    val addressUri = Uri.parse("YourAppScheme:$callerNumber")

    // Define capabilities supported by your call.
    val callCapabilities = CallAttributesCompat.CallCapability(
        supportsSetInactive = CallAttributesCompat.SUPPORTS_SET_INACTIVE // Call can be made inactive (implies hold)
    )

    return CallAttributesCompat(
        displayName = callerName,
        address = addressUri,
        direction = CallAttributesCompat.DIRECTION_INCOMING,
        callType = if (isVideoCall) CallAttributesCompat.CALL_TYPE_VIDEO_CALL else CallAttributesCompat.CALL_TYPE_AUDIO_CALL,
        callCapabilitiesCompat = callCapabilities
    )
}

Anruf hinzufügen

Verwenden Sie callsManager.addCall mit CallAttributesCompat und Rückrufen, um dem System einen neuen Aufruf hinzuzufügen und Remote-Oberflächenupdates zu verwalten. Mit dem callControlScope innerhalb des addCall-Blocks kann Ihre App hauptsächlich den Anrufstatus ändern und Audioupdates empfangen:

try {
    callsManager.addCall(
        INCOMING_CALL_ATTRIBUTES,
        onAnswerCall, // Watch needs to know if it can answer the call.
        onSetCallDisconnected,
        onSetCallActive,
        onSetCallInactive
    ) {
        // The call was successfully added once this scope runs.
        callControlScope = this
    }
}
catch(addCallException: Exception){
   // Handle the addCall failure.
}

Anruf entgegennehmen

So nehmen Sie einen Anruf in der CallControlScope an:

when (val result = answer(CallAttributesCompat.CALL_TYPE_AUDIO_CALL)) {
    is CallControlResult.Success -> { /* Call answered */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

Anruf ablehnen

Anruf mit disconnect() und DisconnectCause.REJECTED in CallControlScope ablehnen:

disconnect(DisconnectCause(DisconnectCause.REJECTED))

Ausgehenden Anruf aktivieren

So legen Sie fest, dass ein ausgehender Anruf aktiv wird, sobald die andere Seite antwortet:

when (val result = setActive()) {
    is CallControlResult.Success -> { /* Call active */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

Halten eines Anrufs

So halten Sie einen Anruf mit setInactive() auf:

when (val result = setInactive()) {
    is CallControlResult.Success -> { /* Call on hold */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

Anruf beenden

So trennen Sie einen Anruf mit disconnect() und DisconnectCause:

disconnect(DisconnectCause(DisconnectCause.LOCAL))

Audioendpunkte für Anrufe verwalten

Audioendpunkte mithilfe von currentCallEndpoint-, availableEndpoints- und isMuted-Flows im CallControlScope beobachten und verwalten

fun observeAudioStateChanges(callControlScope: CallControlScope) {
    with(callControlScope) {
        launch { currentCallEndpoint.collect { /* Update UI */ } }
        launch { availableEndpoints.collect { /* Update UI */ } }
        launch { isMuted.collect { /* Handle mute state */ } }
    }
}

So ändern Sie das aktive Audiogerät mit requestEndpointChange():

coroutineScope.launch {
     callControlScope.requestEndpointChange(callEndpoint)
}

Unterstützung im Vordergrund

Die Bibliothek verwendet ConnectionService (Android 13 API-Level 33 und niedriger) oder foregroundtypes (Android 14 API-Level 34 und höher) für die Unterstützung im Vordergrund.

Gemäß den Anforderungen für den Vordergrund muss die Anwendung eine Benachrichtigung senden, damit Nutzer wissen, dass die Anwendung im Vordergrund ausgeführt wird.

Damit Ihre App die Ausführungspriorität im Vordergrund erhält, erstellen Sie eine Benachrichtigung, sobald Sie den Aufruf über die Plattform hinzugefügt haben. Die Priorität im Vordergrund wird aufgehoben, wenn Ihre App den Anruf beendet oder Ihre Benachrichtigung nicht mehr gültig ist.

Weitere Informationen zu Diensten im Vordergrund

Remote-Support für Surface

Auf Remote-Geräten (Smartwatches, Bluetooth-Headsets, Android Auto) können Anrufe ohne direkte Interaktion mit dem Smartphone verwaltet werden. Ihre App muss Rückruf-Lambdas (onAnswerCall, onSetCallDisconnected, onSetCallActive, onSetCallInactive) implementieren, die an CallsManager.addCall übergeben werden, um von diesen Geräten initiierte Aktionen zu verarbeiten.

Wenn eine Remote-Aktion auftritt, wird das entsprechende Lambda aufgerufen.

Wenn der Lambda-Befehl erfolgreich abgeschlossen wurde, wird signalisiert, dass der Befehl verarbeitet wurde. Wenn der Befehl nicht ausgeführt werden kann, sollte die Lambda-Funktion eine Ausnahme auslösen.

Eine korrekte Implementierung sorgt für eine nahtlose Anrufsteuerung auf verschiedenen Geräten. Testen Sie gründlich mit verschiedenen Remote-Oberflächen.