O framework de telecomunicações do Android (também conhecido simplesmente como "Telecom") gerencia chamadas de áudio e videochamadas em um dispositivo Android. Isso inclui chamadas baseadas em chip, como
chamadas
que usam o framework de telefonia, e chamadas VoIP que implementam a
biblioteca Jetpack Core-Telecom.
Os principais componentes gerenciados pela Telecom são ConnectionService e
InCallService.
Uma implementação de ConnectionService se baseia em tecnologias como PSTN para conectar
chamadas a outras partes. A implementação mais comum de ConnectionService em um
smartphone é o ConnectionService de telefonia. Ele conecta chamadas da operadora.
Uma implementação de InCallService fornece uma interface do usuário para chamadas gerenciadas pela
Telecom e permite que o usuário controle e interaja com essas chamadas. A implementação mais comum de um InCallService é o app Telefone que vem com o dispositivo.
A telecomunicação atua como uma central telefônica. Ele encaminha as chamadas que as implementações de ConnectionService
fornecem para as interfaces do usuário de chamada que as implementações de InCallService
fornecem.
Recomendamos implementar as APIs Telecom pelos seguintes motivos:
- Para criar um substituto para o app Telefone do sistema.
- Para integrar uma solução de chamada à experiência de chamada do Android.
Criar um app Telefone de substituição
Para criar um substituto para o app Telefone padrão em um dispositivo Android, implemente a API InCallService. Sua implementação precisa atender aos seguintes
requisitos:
- Ele não pode ter nenhum recurso de chamada e precisa consistir apenas na interface do usuário para chamadas.
- Ele precisa processar todas as chamadas que o framework de telecomunicações conhece e não fazer
suposições sobre a natureza das chamadas. Por exemplo, ele não pode presumir
que as chamadas são de telefonia baseadas em chip nem implementar restrições de chamada
baseadas em um único
ConnectionService, como a aplicação de restrições de telefonia para videochamadas.
Para saber mais, consulte
InCallService.
Integrar uma solução de chamadas
Para integrar sua solução de chamadas ao Android, você tem as seguintes opções:
Implementar a biblioteca autogerenciada do Jetpack Core-Telecom: essa opção é ideal para desenvolvedores de apps de chamada de vídeo e/ou ligação independentes que não querem mostrar as chamadas no app de telefone padrão nem que outras chamadas sejam mostradas na interface do usuário.
Ao integrar com a biblioteca Jetpack
Core-Telecom, você ajuda seu app a interoperar não apenas com chamadas de telefonia do sistema no dispositivo, mas também com outros apps de chamada de vídeo e/ou ligação independentes que se integram ao Telecom. A bibliotecaCore-Telecomtambém gerencia o roteamento e o foco de áudio. Para mais detalhes, consulte Criar um app de chamada de vídeo e/ou ligação.Implementar a API ConnectionService gerenciada: essa opção facilita o desenvolvimento de uma solução de chamada que depende do aplicativo de telefone do dispositivo para fornecer a interface do usuário para chamadas. Os exemplos incluem uma implementação de terceiros de serviços de chamada SIP e VoIP. Para ver mais detalhes, consulte
getDefaultDialerPackage().Um
ConnectionServicesozinho fornece apenas os meios de conectar chamadas. Ele não tem uma interface do usuário associada.Implementar as APIs InCallService e ConnectionService: essa opção é ideal se você quiser criar sua própria solução de chamadas baseada em
ConnectionService, com uma interface do usuário própria, e também mostrar todas as outras chamadas do Android na mesma interface. Ao usar essa abordagem, sua implementação deInCallServicenão pode fazer suposições sobre as origens das chamadas exibidas. Além disso, sua implementação deConnectionServiceprecisa continuar funcionando sem o app Telefone padrão definido como seuInCallServicepersonalizado.
Filtrar chamadas
Os dispositivos com o Android 10 (nível 29 da API) ou versões mais recentes permitem que o app identifique
ligações de números que não estão na lista de endereços do usuário como possíveis ligações
spam. Os usuários podem optar por rejeitar ligações spam de forma silenciosa. Para oferecer mais
transparência aos usuários quando eles perdem ligações, as informações sobre essas chamadas
bloqueadas são registradas no histórico de ligações. O uso da API do Android 10 elimina o
requisito de receber a permissão
READ_CALL_LOG
do usuário para oferecer a funcionalidade de filtro de ligações e identificador de
chamadas.
Use uma implementação de
CallScreeningService
para filtrar chamadas. Chame a função
onScreenCall()
para todas as novas ligações recebidas ou efetuadas quando o número não estiver na
lista de contatos do usuário. Verifique o objeto
Call.Details para ver informações
sobre a chamada. Especificamente, a função
getCallerNumberVerificationStatus()
inclui informações do provedor de rede sobre o outro número.
Se o status de verificação falhar, isso é uma boa indicação de que a chamada é
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. } } } } }
Defina a função onScreenCall() para chamar
respondToCall()
e informar ao sistema como responder à nova chamada. Essa função usa um parâmetro
CallResponse
que pode ser usado para instruir o sistema a bloquear a chamada, rejeitá-la como se
o usuário tivesse feito isso ou silenciá-la. Você também pode instruir o sistema a não adicionar essa
chamada ao registro 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)
É necessário registrar a implementação de CallScreeningService no arquivo de manifesto
com o filtro de intent e a permissão adequados para que o sistema possa acioná-la
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
Os dispositivos com o Android 10 ou versões mais recentes gerenciam intents de chamada de forma diferente
dos dispositivos com o Android 9 ou versões anteriores. No Android 10 e versões mais recentes, a transmissão
ACTION_NEW_OUTGOING_CALL
foi descontinuada e substituída pela API
CallRedirectionService. O CallRedirectionService fornece interfaces para você
modificar as ligações efetuadas pela plataforma Android. Por exemplo, apps de terceiros
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() } } } }
É necessário registrar esse 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
do RoleManager. Isso vai perguntar
ao usuário se ele quer permitir que o app processe redirecionamentos de chamadas. Se o app
não receber esse papel, o serviço de redirecionamento não será usado.
Verifique se o app tem esse papel quando o usuário o inicia para
solicitá-lo, se necessário. Você inicia uma intent criada pelo RoleManager.
Por isso, substitua a função
onActivityResult()
para processar a seleção do usuário.
class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // 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 } }