Visão geral da biblioteca Telecom

O framework do Android Telecom (também conhecido simplesmente como "Telecom") gerencia áudios e vídeo chamadas em um dispositivo com Android. Isso inclui chamadas baseadas em chip, como ligações que usam a estrutura de telefonia e chamadas VoIP que implementam a API ConnectionService.

Os principais componentes que as telecomunicações gerenciam são ConnectionService e InCallService.

Uma implementação de ConnectionService usa tecnologias como VoIP para se conectar chamadas para outras partes. A implementação de ConnectionService mais comum em um telefone é o ConnectionService de telefonia. Ele conecta as chamadas da operadora.

Uma implementação de InCallService fornece uma interface do usuário para chamadas gerenciadas pelo Telecom e permite que o usuário controle e interaja com essas chamadas. A maior implementação comum de um InCallService é o app para smartphones que acompanha um dispositivo.

As telecomunicações funcionam como um quadro de distribuição. Ele encaminha chamadas que ConnectionService implementações oferecem às interfaces do usuário de chamada que InCallService que as implementações oferecem.

É recomendável implementar as APIs de telecomunicações pelos seguintes motivos:

• Para criar uma substituição para o app de telefone do sistema.
• Integrar uma solução de chamada sobre a experiência de chamada do Android.

Criar um app telefone substituto

Para criar uma substituição para o app de telefone padrão em um dispositivo Android, faça o seguinte: implementar a API InCallService. Sua implementação precisa atender aos seguintes requisitos:

• Ele não pode ter recursos de chamada e precisa consistir apenas do usuário do BigQuery para chamadas.
• Ele precisa processar todas as chamadas que a estrutura de telecomunicações conhece, sem fazer suposições sobre a natureza das ligações. Por exemplo, ele não deve presumir são chamadas telefônicas com base em chips nem implementam restrições de chamadas que são baseados em qualquer ConnectionService, como aplicação de serviço restrições para videochamadas.

Para saber mais, consulte InCallService.

Integrar uma solução de chamada

Para integrar sua solução de chamadas ao Android, você tem o seguintes opções:

• Implemente a API ConnectionService autogerenciada: Essa opção é ideal para desenvolvedores de apps de chamada independentes que não querem para mostrar as chamadas deles no app de telefone padrão, nem mostrar outras chamadas na interface do usuário.

  Ao usar um ConnectionService autogerenciado, você ajuda seu app a interopera não só com as chamadas de telefonia nativa no dispositivo, mas também por outros apps de chamada independentes que implementam essa API. O modelo de gerenciamento A API ConnectionService também gerencia foco e roteamento de áudio. Para mais detalhes, consulte Criar um app de chamadas.

• Implemente a API ConnectionService gerenciada: Essa opção facilita o desenvolvimento de uma solução de chamada que depende das aplicativo de telefone do dispositivo existente para fornecer a interface do usuário para chamadas. Os exemplos incluem uma implementação terceirizada de chamadas SIP e VoIP. serviços. Para ver mais detalhes, consulte getDefaultDialerPackage().

  Um ConnectionService por si só fornece apenas os meios de conectar chamadas. Ela não tem interface do usuário associada.

• Implemente as APIs InCallService e ConnectionService: Essa opção é ideal se você quer criar seu próprio Solução de chamadas com base em ConnectionService, completa com o próprio usuário e também mostrar todas as outras chamadas do Android na mesma interface do usuário. Ao usar essa abordagem, a implementação de InCallService não pode fazer suposições sobre as origens das chamadas exibidas. Além disso, seus implementação de ConnectionService precisa continuar funcionando sem os app de smartphone padrão definido como InCallService personalizado.

Filtrar chamadas

Dispositivos com o Android 10 (nível 29 da API) ou versões mais recentes permitem que o app identifique chamadas de números que não estão no catálogo de endereços do usuário como um possível spam chamadas. Os usuários podem optar por rejeitar chamadas de spam silenciosamente. Para oferecer transparência aos usuários quando eles perdem ligações, informações sobre é registrado no registro de chamadas. Usar a API do Android 10 elimina a requisito para receber READ_CALL_LOG permissão do usuário para fornecer o filtro de ligações e o identificador de chamadas funcionalidade de armazenamento.

Você usa um CallScreeningService implementação para filtrar chamadas. Chame o método onScreenCall() para novas chamadas recebidas ou efetuadas quando o número não estiver no lista de contatos do usuário. Confira a Objeto Call.Details para informações sobre a ligação. Especificamente, os getCallerNumberVerificationStatus() inclui informações da provedora de rede sobre o outro número. Se o status de verificação falhou, esta é uma boa indicação de que a ligação foi de um número inválido ou uma possível ligação spam.

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

Definir a função onScreenCall() para chamar respondToCall() para informar ao sistema como responder à nova chamada. Essa função toma CallResponse que pode ser usado para dizer ao sistema para bloquear a chamada, rejeitá-la como se fosse o que o usuário fez ou silenciá-lo. Você também pode dizer ao sistema para pular a adição dessa a chamada para o registro de chamadas do dispositivo.

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

Registre a implementação de CallScreeningService no manifesto com o filtro de intent e a permissão adequados para que o sistema acione corretamente.

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

Redirecionar uma chamada

Dispositivos com o Android 10 ou versões mais recentes gerenciam intents de chamada de maneira diferente dispositivos com o Android 9 ou versões anteriores. No Android 10 e em versões mais recentes, ACTION_NEW_OUTGOING_CALL transmissão foi descontinuada e substituída pela CallRedirectionService API. O CallRedirectionService fornece interfaces para você usar modificar chamadas realizadas pela plataforma Android. Por exemplo, terceiros eles podem cancelar chamadas e redirecioná-las por 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();
        }
    }
}

Você deve registrar este serviço no manifesto para que o sistema possa iniciá-lo corretamente.

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

Para usar um serviço de redirecionamento, seu app precisa solicitar o papel de redirecionamento de chamadas no RoleManager. Isso vai perguntar o usuário se ele quiser permitir que o app gerencie redirecionamentos de chamada. Se o seu app não receber esse papel, o serviço de redirecionamento não será usado.

Verifique se o aplicativo tem esse papel quando o usuário iniciá-lo. você poderá solicitá-lo conforme necessário. Inicie uma intent criada pela RoleManager. Portanto, não se esqueça de substituir onActivityResult() para lidar com a seleção do usuário.

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