Descripción general del marco de trabajo de Telecom

El framework de Android Telecom (también conocido como "Telecom") administra el audio y videollamadas en un dispositivo con Android. Esto incluye las llamadas basadas en SIM, como llamadas que usan framework de telefonía y llamadas VoIP que implementan el API de ConnectionService.

Los componentes principales que administra Telecom son ConnectionService y InCallService

Una implementación de ConnectionService usa tecnologías como VoIP para conectarse llamadas a otras partes. La implementación de ConnectionService más común en un el teléfono es el ConnectionService de telefonía. Conecta las llamadas mediante operador.

Una implementación de InCallService proporciona una interfaz de usuario para las llamadas administradas por Telecom, y le permite al usuario controlar estas llamadas e interactuar con ellas. El más implementación común de un InCallService es la app para teléfonos que se empaqueta con un dispositivo.

Telecom funciona como conmutador. Enruta llamadas que ConnectionService implementaciones proporcionan a las interfaces de usuario que realizan llamadas InCallService que proporcionan estas implementaciones.

Es posible que desees implementar las APIs de Telecom por las siguientes razones:

Crear una app de teléfono de reemplazo

Si deseas crear un reemplazo para la app de teléfono predeterminada en un dispositivo Android, haz lo siguiente: implementa la API de InCallService. Tu implementación debe cumplir con los siguientes requisitos:

  • No debe admitir funciones de llamadas y debe incluir solo al usuario para realizar llamadas.
  • Debe administrar todas las llamadas que el marco de trabajo de telecomunicaciones conoce y no hacer suposiciones sobre la naturaleza de las llamadas. Por ejemplo, no debe suponer llamadas de telefonía basadas en SIM, ni implementar restricciones de llamadas que se basan en cualquier ConnectionService, como la aplicación de un modelo de telefonía restricciones para las videollamadas.

Para obtener más información, consulta InCallService.

Integrar una solución de llamadas

Para integrar tu solución de llamadas en Android, tienes lo siguiente: las siguientes opciones:

  • Implementa la API de ConnectionService autoadministrada: Esta opción es ideal para los desarrolladores de apps de llamadas independientes que no quieren que para mostrar sus llamadas en la app de teléfono predeterminada ni que se muestren otras llamadas en su interfaz de usuario.

    Cuando usas un ConnectionService autoadministrado, ayudas a que tu app haga lo siguiente: No solo interoperan con llamadas telefónicas nativas en el dispositivo con otras apps de llamadas independientes que implementan esta API. El kit de herramientas La API de ConnectionService también administra el enrutamiento y el foco de audio. Para obtener más información, consulta Compila una app de llamadas.

  • Implementa la API de ConnectionService administrada: Esta opción facilita el desarrollo de una solución de llamadas que se basa en una aplicación de teléfono del dispositivo existente con el fin de proporcionar la interfaz de usuario para las llamadas. Los ejemplos incluyen una implementación externa de llamadas SIP y VoIP de Google Cloud. Consulta getDefaultDialerPackage() para obtener más información.

    Un objeto ConnectionService por sí solo proporciona los medios para conectar llamadas. Integra no tiene una interfaz de usuario asociada.

  • Implementa la API de InCallService y ConnectionService: Esta opción es ideal si deseas crear tus propios Solución de llamadas basada en ConnectionService, con su propio usuario y también mostrar todas las demás llamadas de Android en la misma interfaz de usuario. Cuando usas este enfoque, tu implementación de InCallService no debe hacer suposiciones sobre las fuentes de las llamadas que muestra. Además, tu implementación de ConnectionService debe seguir funcionando sin las la app para teléfonos predeterminada establecida en tu InCallService personalizado.

Filtrar llamadas

Los dispositivos con Android 10 (nivel de API 29) o versiones posteriores permiten que tu app identifique las llamadas de números que no están en la libreta de direcciones del usuario como posible spam llamadas. Los usuarios pueden elegir que se rechacen las llamadas de spam de manera silenciosa. Para proporcionar mayor transparencia para los usuarios cuando pierdan llamadas, información sobre estos bloqueos llamadas se registran en el registro de llamadas. El uso de la API de Android 10 elimina requisito para obtener el READ_CALL_LOG permiso del usuario para proporcionar el número de llamada y el identificador de llamadas funcionalidad.

Se usa un CallScreeningService para filtrar llamadas. Llama al onScreenCall() para las nuevas llamadas entrantes o salientes cuando el número no se encuentra en la lista de contactos del usuario. Puedes consultar Call.Details para obtener información sobre la llamada. En concreto, la getCallerNumberVerificationStatus() incluye información del proveedor de red sobre el otro número. Si el estado de verificación ha fallado, es un buen indicador de que la llamada se a partir de un número no válido o una posible llamada de spam.

Kotlin

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

Java

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

Configura la función onScreenCall() para llamar respondToCall() para indicarle al sistema cómo responder a la llamada nueva. Esta función toma un CallResponse que puedes usar para indicarle al sistema que bloquee la llamada, recházala como si lo hizo el usuario o silenciarla. También puedes indicarle al sistema que omita el paso de agregar esto. llamada al registro de llamadas del dispositivo.

Kotlin

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

Java

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

Debes registrar la implementación de CallScreeningService en el manifiesto con el filtro de intents y el permiso adecuados para que el sistema correctamente.

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

Redireccionar una llamada

Los dispositivos que ejecutan Android 10 o versiones posteriores administran los intents de llamada de manera diferente que dispositivos con Android 9 o versiones anteriores. En Android 10 y versiones posteriores, la ACTION_NEW_OUTGOING_CALL transmisión dejó de estar disponible y se reemplazó por CallRedirectionService en la API de Cloud. CallRedirectionService proporciona interfaces que puedes usar para lo siguiente: modificar las llamadas salientes que realiza la plataforma de Android. Por ejemplo, herramientas de las apps pueden cancelar las llamadas y redirigirlas por VoIP.

Kotlin

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

Java

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

Debes registrar este servicio en el manifiesto para que el sistema pueda iniciarlo correctamente.

<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 un servicio de redireccionamiento, tu app debe solicitar el rol de redireccionamiento de llamadas desde RoleManager. Se te preguntará al usuario si quiere permitir que tu app administre los redireccionamientos de llamadas. Si su aplicación si no se le otorga este rol, no se usa tu servicio de redireccionamiento.

Debes comprobar si tu app tiene este rol cuando el usuario la inicie puedes solicitarla según sea necesario. Inicias un intent creado por RoleManager, así que asegúrate de anular el onActivityResult() para controlar la selección del usuario.

Kotlin

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

Java

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