Telecom-Framework – Übersicht

Das Android Telecom-Framework (auch bekannt als "Telecom") verwaltet Audio- und für Videoanrufe auf einem Android-Gerät. Dazu gehören auch SIM-basierte Anrufe wie Anrufe die das Telefonie-Framework nutzen, sowie VoIP-Anrufe, ConnectionService API

Die Hauptkomponenten, die die Telecom verwaltet, sind ConnectionService und InCallService

Bei einer ConnectionService-Implementierung werden Technologien wie VoIP verwendet, um eine Verbindung herzustellen. Anrufe an andere Parteien. Die gängigste ConnectionService-Implementierung auf einem Telefon ist die Telefonie-ConnectionService. Anrufe über Mobilfunkanbieter werden miteinander verbunden.

Eine InCallService-Implementierung bietet eine Benutzeroberfläche für Aufrufe, die von Telekommunikation. Der Nutzer kann diese Anrufe steuern und mit ihnen interagieren. Die meisten Die gängige Implementierung von InCallService ist die Smartphone-App, die mit auf einem Gerät.

Die Telekommunikation fungiert als Telefontafel. Sie leitet Anrufe weiter, die ConnectionService Implementierungen für die aufrufenden Benutzeroberflächen, die InCallService -Implementierungen bieten.

Aus folgenden Gründen kann es sinnvoll sein, die Telekommunikations-APIs zu implementieren:

• So erstellen Sie einen Ersatz für die Systemtelefon-App.
• Um eine Anruflösung einzubinden in die Android-Anruffunktionen einfließen lassen.

Ersatz-Smartphone-App erstellen

So erstellst du einen Ersatz für die Standard-Telefon-App auf einem Android-Gerät: Implementieren Sie die InCallService API. Ihre Implementierung muss folgende Anforderungen erfüllen Anforderungen:

• Er darf keine Anruffunktion haben und darf ausschließlich aus dem Nutzer bestehen. für die Aufrufe an.
• Sie muss alle Anrufe verarbeiten, die dem Telekommunikations-Framework bekannt sind, und keine Annahmen zur Art der Anrufe treffen. Es darf beispielsweise nicht davon ausgehen, sind SIM-basierte Telefonieanrufe und es werden keine Anrufeinschränkungen implementiert, die basieren auf einem ConnectionService, wie z. B. der Durchsetzung von Telefoniefunktionen Einschränkungen für Videoanrufe.

Weitere Informationen finden Sie unter InCallService

Anruflösung einbinden

Um Ihre Anruflösung in Android zu integrieren, haben Sie folgende Optionen:

• Implementieren Sie die selbstverwaltete ConnectionService API: Diese Option ist ideal für Entwickler von eigenständigen Anruf-Apps, , um die Anrufe in der Standard-App "Telefon" oder andere Anrufe anzuzeigen. auf ihrer Benutzeroberfläche.

  Wenn du ein selbstverwaltetes ConnectionService verwendest, hilfst du deiner App dabei, mit nativen Telefonieanrufen auf dem Gerät interagieren, anderen eigenständigen aufrufenden Apps, die diese API implementieren. Die selbstverwaltete Die ConnectionService API verwaltet auch das Audiorouting und den Fokus. Weitere Informationen finden Sie unter Anruf-App erstellen

• Implementieren Sie die verwaltete ConnectionService API: Diese Option erleichtert die Entwicklung einer Anruflösung, die auf dem vorhandene Telefonanwendung auf dem Gerät, um die Benutzeroberfläche für Anrufe bereitzustellen. Beispiele hierfür sind die Implementierung von SIP- und VoIP-Anrufen durch Drittanbieter Dienstleistungen. Weitere Informationen finden Sie unter getDefaultDialerPackage()

  Eine ConnectionService allein bietet nur die Möglichkeit, Anrufe zu verbinden. Es verfügt über keine zugehörige Benutzeroberfläche.

• Implementieren Sie sowohl die InCallService API als auch die ConnectionService API: Diese Option ist ideal, wenn Sie Anruflösung über ConnectionService mit eigenem Nutzer und alle anderen Android-Aufrufe in derselben Benutzeroberfläche. Wenn Sie diesen Ansatz verwenden, darf Ihre Implementierung von InCallService nicht Annahmen über die Quellen der angezeigten Aufrufe treffen. Außerdem können Ihre Die Implementierung von ConnectionService muss auch ohne das Standard-Telefon-App, die auf deine benutzerdefinierte InCallService festgelegt ist.

Anruf-Filter

Auf Geräten mit Android 10 (API-Level 29) oder höher kann deine App Anrufe von Nummern, die nicht im Adressbuch des Nutzers stehen, als potenzieller Spam Anrufe. Nutzer können festlegen, dass Spamanrufe automatisch abgelehnt werden. Um eine bessere Transparenz für Nutzer, wenn sie Anrufe verpassen, Informationen zu diesen blockierten Anrufe werden in der Anrufliste gespeichert. Die Android 10 API eliminiert die die Anforderung, die READ_CALL_LOG Berechtigung des Nutzers, um Anruf-Filter und Anrufer-IDs zu ermöglichen Funktionalität.

Sie verwenden eine CallScreeningService um Anrufe zu filtern. Rufen Sie die Methode onScreenCall() für neue ein- oder ausgehende Anrufe, wenn die Nummer nicht im in der Kontaktliste des Nutzers. Sie können die Objekt Call.Details für Informationen über den Anruf. Konkret bedeutet das getCallerNumberVerificationStatus() enthält Informationen des Netzbetreibers über die andere Nummer. Ist der Bestätigungsstatus fehlgeschlagen, ist dies ein Hinweis darauf, dass der Anruf von einer ungültigen Nummer oder einem potenziellen Spamanruf stammt.

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

Die aufzurufende onScreenCall()-Funktion festlegen respondToCall() um dem System mitzuteilen, wie auf den neuen Anruf reagiert werden soll. Diese Funktion verwendet eine CallResponse können Sie das System anweisen, den Anruf zu blockieren und ihn so abzulehnen, als ob die der Nutzer getan hat, oder ihn stumm schalten. Sie können das System auch anweisen, das Hinzufügen Anruf in die Anrufliste des Geräts ein.

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

Sie müssen die CallScreeningService-Implementierung im Manifest registrieren Datei mit dem entsprechenden Intent-Filter und der entsprechenden Berechtigung, damit das System es richtig machen.

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

Anruf weiterleiten

Auf Geräten mit Android 10 oder höher werden Anruf-Intents anders verwaltet als mit Android 9 oder niedriger. Unter Android 10 und höher ACTION_NEW_OUTGOING_CALL Broadcast wurde eingestellt und durch den CallRedirectionService der API erstellen. Der CallRedirectionService stellt Schnittstellen zur Verfügung, die Sie für folgende Aktionen verwenden können: Ausgehende Anrufe über die Android-Plattform ändern Beispiel: Drittanbieter Apps können Anrufe abbrechen und über VoIP umleiten.

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

Sie müssen diesen Dienst im Manifest registrieren, damit das System ihn starten kann korrekt sind.

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

Damit Sie einen Weiterleitungsdienst verwenden können, muss Ihre App die Rolle „Anrufweiterleitung“ anfordern aus dem RoleManager. Sie werden gefragt, ob Ihre App Anrufweiterleitungen verarbeiten darf. Wenn Ihre App diese Rolle nicht gewährt wird, wird Ihr Weiterleitungsdienst nicht verwendet.

Sie sollten prüfen, ob Ihre App diese Rolle hat, wenn der Nutzer Ihre App startet, damit können Sie sie bei Bedarf anfordern. Sie starten einen von RoleManager erstellten Intent, überschreiben Sie die onActivityResult() die Auswahl der Nutzenden.

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