Interactúa con el Centro de seguridad

Redirecciona al Centro de seguridad

Cualquier app puede abrir el Centro de seguridad con la acción android.content.Intent.ACTION_SAFETY_CENTER (valor de cadena android.intent.action.SAFETY_CENTER).

Para abrir Safety Center, realiza una llamada desde una instancia de Activity:

Intent openSafetyCenterIntent = new Intent(Intent.ACTION_SAFETY_CENTER);

startActivity(openSafetyCenterIntent);

Redirecciona a un problema específico

También es posible redireccionar a una tarjeta de advertencia específica del Centro de seguridad con extras de intent específicos. Estos elementos adicionales no están diseñados para que los usen terceros, por lo que forman parte de SafetyCenterManager, que forma parte de @SystemApi. Solo las apps del sistema pueden acceder a estos elementos adicionales.

Intent extras que redireccionan una tarjeta de advertencia específica:

  • EXTRA_SAFETY_SOURCE_ID
    • Valor de cadena: android.safetycenter.extra.SAFETY_SOURCE_ID
    • Tipo de cadena: Especifica el ID de la fuente de seguridad de la tarjeta de advertencia asociada.
    • Obligatorio para que funcione el redireccionamiento al problema
  • EXTRA_SAFETY_SOURCE_ISSUE_ID
    • Valor de cadena: android.safetycenter.extra.SAFETY_SOURCE_ISSUE_ID
    • Tipo de cadena: Especifica el ID de la tarjeta de advertencia
    • Obligatorio para que funcione el redireccionamiento al problema
  • EXTRA_SAFETY_SOURCE_USER_HANDLE
    • Valor de cadena: android.safetycenter.extra.SAFETY_SOURCE_USER_HANDLE
    • Tipo UserHandle: Especifica UserHandle para la tarjeta de advertencia asociada.
    • Opcional (el valor predeterminado es el usuario actual)

El siguiente fragmento de código se puede usar desde una instancia de Activity para abrir la pantalla del Centro de seguridad y detectar un problema específico:

UserHandle theUserHandleThisIssueCameFrom = …;

Intent openSafetyCenterIntent = new Intent(Intent.ACTION_SAFETY_CENTER)
.putExtra(SafetyCenterManager.EXTRA_SAFETY_SOURCE_ID, "TheSafetySourceIdThisIssueCameFrom")
.putExtra(SafetyCenterManager.EXTRA_SAFETY_SOURCE_ISSUE_ID, "TheSafetySourceIssueIdToRedirectTo")
.putExtra(SafetyCenterManager.EXTRA_SAFETY_SOURCE_USER_HANDLE, theUserHandleThisIssueCameFrom);

startActivity(openSafetyCenterIntent);

Redirecciona a una subpágina específica (a partir de Android 14)

En Android 14 o versiones posteriores, la página del Centro de seguridad se divide en varias subpáginas que representan los diferentes SafetySourcesGroup (en Android 13, esto se muestra como entradas que se pueden contraer).

Es posible redireccionar a una subpágina específica con este intent adicional:

  • EXTRA_SAFETY_SOURCES_GROUP_ID
    • Valor de cadena: android.safetycenter.extra.SAFETY_SOURCES_GROUP_ID
    • Tipo de cadena: Especifica el ID de SafetySourcesGroup.
    • Obligatorio para que funcione el redireccionamiento a la subpágina

El siguiente fragmento de código se puede usar desde una instancia de Activity para abrir la pantalla del Centro de seguridad en una subpágina específica:

Intent openSafetyCenterIntent = new Intent(Intent.ACTION_SAFETY_CENTER)
.putExtra(SafetyCenterManager.EXTRA_SAFETY_SOURCES_GROUP_ID, "TheSafetySourcesGroupId");

startActivity(openSafetyCenterIntent);

Usa las APIs de fuente de Safety Center

Las APIs de origen del Centro de seguridad están disponibles usando SafetyCenterManager (que es un @SystemApi). El código para la plataforma de la API está disponible en Code Search. El código de implementación de las APIs está disponible en Code Search.

Permisos

Solo las apps del sistema incluidas en la lista de entidades permitidas pueden acceder a las APIs de origen de Safety Center con los permisos que se indican a continuación. Para obtener más información, consulta Inclusión de permisos con privilegios en la lista de entidades permitidas.

  • READ_SAFETY_CENTER_STATUS
    • signature|privileged
    • Se usa para la API de SafetyCenterManager#isSafetyCenterEnabled() (no es necesario para las fuentes de Safety Center, solo necesitan el permiso SEND_SAFETY_CENTER_UPDATE).
    • Lo usan las apps del sistema que verifican si el Centro de seguridad está habilitado.
    • Solo se otorga a las apps del sistema incluidas en la lista de entidades permitidas
  • SEND_SAFETY_CENTER_UPDATE
    • internal|privileged
    • Se usa para la API habilitada y la API de Safety Sources.
    • Solo lo usan las fuentes de seguridad
    • Solo se otorga a las apps del sistema incluidas en la lista de entidades permitidas

Estos permisos son de privilegio y solo puedes adquirirlos si los agregas al archivo relevante, por ejemplo, al archivo com.android.settings.xml de la app de Configuración y al archivo AndroidManifest.xml de la app. Consulta protectionLevel para obtener más información sobre el modelo de permisos.

Obtén SafetyCenterManager

SafetyCenterManager es una clase @SystemApi a la que se puede acceder desde apps del sistema a partir de Android 13. En esta llamada, se muestra cómo obtener SafetyCenterManager:

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
  // Must be on T or above to interact with Safety Center.
  return;
}
SafetyCenterManager safetyCenterManager = context.getSystemService(SafetyCenterManager.class);
if (safetyCenterManager == null) {
  // Should not be null on T.
  return;
}

Cómo verificar si el Centro de seguridad está habilitado

Esta llamada verifica si se habilitó el Centro de seguridad. La llamada requiere el permiso READ_SAFETY_CENTER_STATUS o SEND_SAFETY_CENTER_UPDATE:

boolean isSafetyCenterEnabled = safetyCenterManager.isSafetyCenterEnabled();
if (isSafetyCenterEnabled) {
  // …
} else {
  // …
}

Proporciona datos

Los datos de origen de Safety Center con el String sourceId determinado se proporcionan a Safety Center con el objeto SafetySourceData, que representa una entrada de la IU y una lista de problemas (tarjetas de advertencia). La entrada de la IU y las tarjetas de advertencia pueden tener diferentes niveles de gravedad especificados en la clase SafetySourceData:

  • SEVERITY_LEVEL_UNSPECIFIED
    • No se especificó la gravedad
    • Color: Gris o transparente (según el SafetySourcesGroup de la entrada)
    • Se usa para datos dinámicos que se presenten como una entrada estática en la IU o para mostrar una entrada no especificada.
    • No se debe usar para tarjetas de advertencia
  • SEVERITY_LEVEL_INFORMATION
    • Información básica o sugerencia menor
    • Color: Verde
  • SEVERITY_LEVEL_RECOMMENDATION
    • Recomendación de que el usuario debe tomar medidas con respecto a este problema, ya que podría ponerlo en riesgo
    • Color: Amarillo
  • SEVERITY_LEVEL_CRITICAL_WARNING
    • Advertencia importante que indica que el usuario debe tomar medidas con respecto a este problema, ya que representa un riesgo
    • Color: Rojo

SafetySourceData

El objeto SafetySourceData consta de una entrada de IU, invariantes y tarjetas de advertencia.

  • Instancia opcional de SafetySourceStatus (entrada de la IU)
  • Lista de instancias de SafetySourceIssue (tarjetas de advertencia)
  • Elementos adicionales opcionales de Bundle (a partir de la versión 14)
  • Invarianzas:
    • La lista SafetySourceIssue debe estar compuesta por problemas con identificadores únicos.
    • La instancia de SafetySourceIssue no debe ser más importante que SafetySourceStatus si hay una (a menos que SafetySourceStatus sea SEVERITY_LEVEL_UNSPECIFIED, en cuyo caso se permiten problemas de SEVERITY_LEVEL_INFORMATION).
    • Se deben cumplir los requisitos adicionales que impone la configuración de la API. Por ejemplo, si la fuente solo tiene problemas, no debe proporcionar una instancia de SafetySourceStatus.

SafetySourceStatus

  • Título CharSequence obligatorio
  • Resumen obligatorio de CharSequence
  • Nivel de gravedad requerido
  • Instancia opcional de PendingIntent para redireccionar al usuario a la página correcta (el valor predeterminado usa intentAction de la configuración, si corresponde)
  • IconAction opcional (se muestra como un ícono lateral en la entrada) que consta de lo siguiente:
    • Es el tipo de ícono obligatorio, que debe ser uno de los siguientes:
      • ICON_TYPE_GEAR: Se muestra como un engranaje junto a la entrada de la IU.
      • ICON_TYPE_INFO: Se muestra como un ícono de información junto a la entrada de la IU.
    • PendingIntent obligatorio para redireccionar al usuario a otra página
  • Es un valor booleano enabled opcional que permite marcar la entrada de la IU como inhabilitada, de modo que no se pueda hacer clic en ella (el valor predeterminado es true).
  • Invariantes:
    • Las instancias de PendingIntent deben abrir una instancia de Activity.
    • Si la entrada está inhabilitada, se debe designar como SEVERITY_LEVEL_UNSPECIFIED.
    • Son requisitos adicionales que impone la configuración de la API.

SafetySourceIssue

  • Identificador único obligatorio de String
  • Título CharSequence obligatorio
  • Subtítulo CharSequence opcional
  • Resumen obligatorio de CharSequence
  • Nivel de gravedad obligatorio
  • Categoría del problema opcional, que debe ser una de las siguientes:
    • ISSUE_CATEGORY_DEVICE: El problema afecta al dispositivo del usuario.
    • ISSUE_CATEGORY_ACCOUNT: El problema afecta a las cuentas del usuario.
    • ISSUE_CATEGORY_GENERAL: El problema afecta la seguridad general del usuario. Es el valor predeterminado.
    • ISSUE_CATEGORY_DATA (a partir de Android 14): El problema afecta los datos del usuario.
    • ISSUE_CATEGORY_PASSWORDS (a partir de Android 14): El problema afecta las contraseñas del usuario.
    • ISSUE_CATEGORY_PERSONAL_SAFETY (A partir de Android 14): El problema afecta la seguridad personal del usuario.
  • Es la lista de elementos Action que el usuario puede tomar para este problema, cada instancia de Action se compone de lo siguiente:
    • Es el identificador String único obligatorio.
    • Etiqueta CharSequence obligatoria
    • Es obligatorio que PendingIntent redireccione al usuario a otra página o procese la acción directamente desde la pantalla del Centro de seguridad.
    • Booleano opcional para especificar si este problema se puede resolver directamente desde la pantalla de SafetyCenter (el valor predeterminado es false)
    • Mensaje de éxito CharSequence opcional, que se mostrará al usuario cuando el problema se resuelva correctamente directamente desde la pantalla del Centro de seguridad
  • PendingIntent opcional al que se llama cuando el usuario descarta el problema (la opción predeterminada es que no se llame a nada)
  • Es el identificador de tipo de problema String obligatorio, que es similar al identificador de problema, pero no tiene que ser único y se usa para el registro.
  • Es un String opcional para el ID de anulación de duplicación que permite publicar la misma SafetySourceIssue desde diferentes fuentes y mostrarla solo una vez en la IU, suponiendo que tienen el mismo deduplicationGroup (a partir de Android 14). Si no se especifica, el problema nunca se elimina.
  • CharSequence opcional para el título de atribución. Es un texto que muestra dónde se originó la tarjeta de advertencia (a partir de Android 14). Si no se especifica, se usa el título de la SafetySourcesGroup.
  • Accesibilidad opcional al problema (a partir de Android 14), que debe ser una de las siguientes opciones:
    • ISSUE_ACTIONABILITY_MANUAL: El usuario debe resolver este problema manualmente. Es el valor predeterminado.
    • ISSUE_ACTIONABILITY_TIP: Este problema es solo una sugerencia y es posible que no requiera ninguna entrada del usuario.
    • ISSUE_ACTIONABILITY_AUTOMATIC: Este problema ya se solucionó y es posible que no requiera ninguna entrada del usuario.
  • Comportamiento de notificación opcional (a partir de Android 14), que debe ser uno de los siguientes:
    • NOTIFICATION_BEHAVIOR_UNSPECIFIED: El Centro de seguridad decidirá si se necesita una notificación para la tarjeta de advertencia. Es el valor predeterminado.
    • NOTIFICATION_BEHAVIOR_NEVER: No se publica ninguna notificación.
    • NOTIFICATION_BEHAVIOR_DELAYED: Se publica una notificación un tiempo después de que se informa el problema por primera vez.
    • NOTIFICATION_BEHAVIOR_IMMEDIATELY: Se publica una notificación en cuanto se informa el problema.
  • Notification opcional para mostrar una notificación personalizada con la tarjeta de advertencia (a partir de Android 14) Si no se especifica, el Notification se deriva de la tarjeta de advertencia. Se compone de lo siguiente:
    • Título CharSequence obligatorio
    • Resumen obligatorio de CharSequence
    • Lista de elementos Action que el usuario puede tomar para esta notificación
  • Invariantes:
    • La lista de instancias de Action debe estar compuesta por acciones con identificadores únicos.
    • La lista de instancias de Action debe contener uno o dos elementos Action. Si la capacidad de acción no es ISSUE_ACTIONABILITY_MANUAL, se permite tener cero Action.
    • El PendingIntent de OnDismiss no debe abrir una instancia de Activity.
    • Requisitos adicionales que impone la configuración de la API

Los datos se proporcionan a Safety Center en ciertos eventos, por lo que es necesario especificar qué causó que la fuente le proporcionara a SafetySourceData una instancia de SafetyEvent.

SafetyEvent

  • Es el tipo obligatorio, que debe ser uno de los siguientes:
    • SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED: El estado de la fuente cambió.
    • SAFETY_EVENT_TYPE_REFRESH_REQUESTED: Responde a una señal de actualización o nuevo análisis del Centro de seguridad. Usa esto en lugar de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED para que el Centro de seguridad pueda hacer un seguimiento de la solicitud de actualización o nuevo análisis.
    • SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED: Solucionamos SafetySourceIssue.Action directamente desde la pantalla de Safety Center. Usa esto en lugar de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED para que Safety Center pueda hacer un seguimiento de la resolución de SafetySourceIssue.Action.
    • SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED: Intentamos resolver SafetySourceIssue.Action directamente desde la pantalla del Centro de seguridad, pero no pudimos hacerlo. Usa esto en lugar de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED para que el Centro de seguridad pueda hacer un seguimiento de que SafetySourceIssue.Action falló.
    • SAFETY_EVENT_TYPE_DEVICE_LOCALE_CHANGED: El idioma del dispositivo cambió, por lo que actualizamos el texto de los datos proporcionados. Se permite usar SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED para esto.
    • SAFETY_EVENT_TYPE_DEVICE_REBOOTED: Proporcionamos estos datos como parte de un inicio inicial, ya que los datos del Centro de seguridad no persisten durante los reinicios. Se permite usar SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED para esto.
  • Es el identificador String opcional para el ID de transmisión de actualización.
  • Es el identificador String opcional para la instancia SafetySourceIssue que se está resolviendo.
  • Es el identificador String opcional para la instancia SafetySourceIssue.Action que se resuelve.
  • Invarianzas:
    • Se debe proporcionar el ID de transmisión de actualización si el tipo es SAFETY_EVENT_TYPE_REFRESH_REQUESTED.
    • Se deben proporcionar los IDs del problema y la acción si el tipo es SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED o SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED.

A continuación, se muestra un ejemplo de cómo una fuente puede proporcionar datos a Safety Center (en este caso, proporciona una entrada con una sola tarjeta de advertencia):

PendingIntent redirectToMyScreen =
    PendingIntent.getActivity(
        context, requestCode, redirectToMyScreenIntent, PendingIntent.FLAG_IMMUTABLE);
SafetySourceData safetySourceData =
    new SafetySourceData.Builder()
        .setStatus(
            new SafetySourceStatus.Builder(
                    "title", "summary", SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION)
                .setPendingIntent(redirectToMyScreen)
                .build())
        .addIssue(
            new SafetySourceIssue.Builder(
                    "MyIssueId",
                    "title",
                    "summary",
                    SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION,
                    "MyIssueTypeId")
                .setSubtitle("subtitle")
                .setIssueCategory(SafetySourceIssue.ISSUE_CATEGORY_DEVICE)
                .addAction(
                    new SafetySourceIssue.Action.Builder(
                            "MyIssueActionId", "label", redirectToMyScreen)
                        .build())
                .build())
        .build();
SafetyEvent safetyEvent = new SafetyEvent.Builder(SafetyEvent.SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED).build();
safetyCenterManager.setSafetySourceData("MySourceId", safetySourceData, safetyEvent);

Obtener los últimos datos proporcionados

Puedes obtener los últimos datos proporcionados al Centro de seguridad de una fuente que pertenece a tu app. Puedes usar esto para mostrar algo en tu propia IU, verificar si los datos deben actualizarse antes de realizar una operación costosa o proporcionar la misma instancia de SafetySourceData al Centro de seguridad con algunos cambios o con una nueva instancia de SafetyEvent. También es útil para hacer pruebas.

Usa este código para obtener los últimos datos proporcionados al Centro de seguridad:

SafetySourceData lastDataProvided = safetyCenterManager.getSafetySourceData("MySourceId");

Informar un error

Si no puedes recopilar datos de SafetySourceData, puedes informar el error a Safety Center, que cambia la entrada a gris, borra los datos almacenados en caché y muestra un mensaje similar a No se pudo verificar la configuración. También puedes informar un error si una instancia de SafetySourceIssue.Action no se resuelve, en cuyo caso no se borran los datos almacenados en caché ni se cambia la entrada de la IU, pero se muestra un mensaje al usuario para informarle que se produjo un error.

Puedes proporcionar el error con SafetySourceErrorDetails, que se compone de lo siguiente:

  • SafetySourceErrorDetails: Instancia SafetyEvent obligatoria:
// An error has occurred in the background, need to clear the Safety Center data to avoid showing data that may not be valid anymore
SafetyEvent safetyEvent = new SafetyEvent.Builder(SafetyEvent.SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED).build();
SafetySourceErrorDetails safetySourceErrorDetails = new SafetySourceErrorDetails(safetyEvent);
safetyCenterManager.reportSafetySourceError("MySourceId", safetySourceErrorDetails);

Cómo responder a una solicitud de actualización o volver a analizar

Puedes obtener una señal del Centro de seguridad para proporcionar datos nuevos. Responder a una solicitud de actualización o nuevo análisis garantiza que el usuario vea el estado actual cuando abra el Centro de seguridad y cuando presione el botón de análisis.

Para ello, recibe una transmisión con la siguiente acción:

  • ACTION_REFRESH_SAFETY_SOURCES
    • Valor de cadena: android.safetycenter.action.REFRESH_SAFETY_SOURCES
    • Se activa cuando Safety Center envía una solicitud para actualizar los datos de la fuente de seguridad de una app determinada.
    • Intent protegido que solo puede enviar el sistema
    • Se envía a todas las fuentes de seguridad en el archivo de configuración como un intent explícito y requiere el permiso SEND_SAFETY_CENTER_UPDATE.

Como parte de esta transmisión, se proporcionan los siguientes extras:

  • EXTRA_REFRESH_SAFETY_SOURCE_IDS
    • Valor de cadena: android.safetycenter.extra.REFRESH_SAFETY_SOURCE_IDS
    • El tipo de array de cadenas (String[]) representa los IDs de origen que se deben actualizar para la app determinada.

  • EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE

    • Valor de cadena: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_REQUEST_TYPE
    • Es un tipo de número entero que representa un tipo de solicitud @IntDef.
    • Debe ser una de las siguientes opciones:
      • EXTRA_REFRESH_REQUEST_TYPE_GET_DATA: Solicita a la fuente que proporcione datos con relativa rapidez, por lo general, cuando el usuario abre la página.
      • EXTRA_REFRESH_REQUEST_TYPE_FETCH_FRESH_DATA: Solicita a la fuente que proporcione datos lo más actualizados posible, por lo general, cuando el usuario presiona el botón de volver a analizar.

  • EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID

    • Valor de cadena: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_BROADCAST_ID
    • Tipo de cadena representa un identificador único para la actualización solicitada

Para obtener una señal del Centro de seguridad, implementa una instancia de BroadcastReceiver. La transmisión se envía con un BroadcastOptions especial que permite al receptor iniciar un servicio en primer plano.

BroadcastReceiver responde a una solicitud de actualización:

public final class SafetySourceReceiver extends BroadcastReceiver {
  // All the safety sources owned by this application.
  private static final String[] ALL_SAFETY_SOURCES = new String[] {"MySourceId1", "…"};
  @Override
  public void onReceive(Context context, Intent intent) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
      // Must be on T or above to interact with Safety Center.
      return;
    }
    String action = intent.getAction();
    if (!SafetyCenterManager.ACTION_REFRESH_SAFETY_SOURCES.equals(action)) {
      return;
    }
    String refreshBroadcastId =
        intent.getStringExtra(SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID);
    if (refreshBroadcastId == null) {
      // Should always be provided.
      return;
    }
    String[] sourceIds =
        intent.getStringArrayExtra(SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCE_IDS);
    if (sourceIds == null) {
      sourceIds = ALL_SAFETY_SOURCES;
    }
    int requestType =
        intent.getIntExtra(
            SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE,
            SafetyCenterManager.EXTRA_REFRESH_REQUEST_TYPE_GET_DATA);
    SafetyCenterManager safetyCenterManager = context.getSystemService(SafetyCenterManager.class);
    if (safetyCenterManager == null) {
      // Should not be null on T.
      return;
    }
    if (!safetyCenterManager.isSafetyCenterEnabled()) {
      // Preferably, no Safety Source code should be run if Safety Center is disabled.
      return;
    }
    SafetyEvent refreshSafetyEvent =
        new SafetyEvent.Builder(SafetyEvent.SAFETY_EVENT_TYPE_REFRESH_REQUESTED)
            .setRefreshBroadcastId(refreshBroadcastId)
            .build();
    for (String sourceId : sourceIds) {
      SafetySourceData safetySourceData = getSafetySourceDataFor(sourceId, requestType);
      // Set the data (or report an error with reportSafetySourceError, if something went wrong).
      safetyCenterManager.setSafetySourceData(sourceId, safetySourceData, refreshSafetyEvent);
    }
  }
  private SafetySourceData getSafetySourceDataFor(String sourceId, int requestType) {
    switch (requestType) {
      case SafetyCenterManager.EXTRA_REFRESH_REQUEST_TYPE_GET_DATA:
        return getRefreshSafetySourceDataFor(sourceId);
      case SafetyCenterManager.EXTRA_REFRESH_REQUEST_TYPE_FETCH_FRESH_DATA:
        return getRescanSafetySourceDataFor(sourceId);
      default:
    }
    return getRefreshSafetySourceDataFor(sourceId);
  }
  // Data to provide when the user opens the page or on specific events.
  private SafetySourceData getRefreshSafetySourceDataFor(String sourceId) {
    // Get data for the source, if it's a fast operation it could potentially be executed in the
    // receiver directly.
    // Otherwise, it must start some kind of foreground service or expedited job.
    return null;
  }
  // Data to provide when the user pressed the rescan button.
  private SafetySourceData getRescanSafetySourceDataFor(String sourceId) {
    // Could be implemented the same way as getRefreshSafetySourceDataFor, depending on the source's
    // need.
    // Otherwise, could potentially perform a longer task.
    // In which case, it must start some kind of foreground service or expedited job.
    return null;
  }
}

La misma instancia de BroadcastReceiver en el ejemplo anterior se declara en AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="…">
    <application>
    <!-- … -->
        <receiver android:name=".SafetySourceReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="android.safetycenter.action.REFRESH_SAFETY_SOURCES"/>
            </intent-filter>
        </receiver>
    <!-- … -->
    </application>
</manifest>

Lo ideal es que una fuente de Safety Center se implemente de manera tal que llame a SafetyCenterManager cuando cambien sus datos. Por motivos de estado del sistema, te recomendamos que respondas solo a la señal de nuevo análisis (cuando el usuario presiona el botón de análisis) y no cuando abre el Centro de seguridad. Si se requiere esta funcionalidad, se debe configurar el campo refreshOnPageOpenAllowed="true" en el archivo de configuración para que la fuente reciba la transmisión que se entrega en estos casos.

Cómo responder al Centro de seguridad cuando está habilitado o inhabilitado

Puedes responder cuando el Centro de seguridad esté habilitado o inhabilitado con esta acción de intent:

  • ACTION_SAFETY_CENTER_ENABLED_CHANGED
    • Valor de cadena: android.safetycenter.action.SAFETY_CENTER_ENABLED_CHANGED
    • Se activa cuando el Centro de seguridad se habilita o inhabilita mientras el dispositivo está en funcionamiento.
    • No se llama durante el inicio (usa ACTION_BOOT_COMPLETED para eso).
    • Intent protegido que solo puede enviar el sistema
    • Se envía a todas las fuentes de seguridad en el archivo de configuración como un intent explícito y requiere el permiso SEND_SAFETY_CENTER_UPDATE.
    • Se envía como un intent implícito que requiere el permiso READ_SAFETY_CENTER_STATUS.

Esta acción de intent es útil para habilitar o inhabilitar funciones relacionadas con Safety Center en el dispositivo.

Implementa acciones de resolución

Una acción de resolución es una instancia de SafetySourceIssue.Action que un usuario puede resolver directamente desde la pantalla de Safety Center. El usuario presiona un botón de acción y se activa la instancia de PendingIntent en SafetySourceIssue.Action que envió la fuente de seguridad, lo que resuelve el problema en segundo plano y notifica al Centro de seguridad cuando se completa.

Para implementar acciones de resolución, la fuente del Centro de seguridad puede usar un servicio si se espera que la operación tome un tiempo (PendingIntent.getService) o un receptor de emisión (PendingIntent.getBroadcast).

Usa este código para enviar un problema de resolución al Centro de seguridad:

Intent resolveIssueBroadcastIntent =
    new Intent("my.package.name.MY_RESOLVING_ACTION").setClass(ResolveActionReceiver.class);
PendingIntent resolveIssue =
    PendingIntent.getBroadcast(
        context, requestCode, resolveIssueBroadcastIntent, PendingIntent.FLAG_IMMUTABLE);
SafetySourceData safetySourceData =
    new SafetySourceData.Builder()
        .setStatus(
            new SafetySourceStatus.Builder(
                    "title", "summary", SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION)
                .setPendingIntent(redirectToMyScreen)
                .build())
        .addIssue(
            new SafetySourceIssue.Builder(
                    "MyIssueId",
                    "title",
                    "summary",
                    SafetySourceData.SEVERITY_LEVEL_RECOMMENDATION,
                    "MyIssueTypeId")
                .setIssueCategory(SafetySourceIssue.ISSUE_CATEGORY_DEVICE)
                .addAction(
                    new SafetySourceIssue.Action.Builder(
                            "MyIssueActionId", "label", resolveIssue)
                        .setWillResolve(true)
                        .build())
                .build())
        .build();
SafetyEvent safetyEvent = new SafetyEvent.Builder(SafetyEvent.SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED).build();
safetyCenterManager.setSafetySourceData("MySourceId", safetySourceData, safetyEvent);

BroadcastReceiver resuelve la acción:

public final class ResolveActionReceiver extends BroadcastReceiver {
  private static final String MY_RESOLVING_ACTION = "my.package.name.MY_RESOLVING_ACTION";
  @Override
  public void onReceive(Context context, Intent intent) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
      // Must be on T or above to interact with Safety Center.
      return;
    }
    String action = intent.getAction();
    if (!MY_RESOLVING_ACTION.equals(action)) {
      return;
    }
    SafetyCenterManager safetyCenterManager = context.getSystemService(SafetyCenterManager.class);
    if (safetyCenterManager == null) {
      // Should not be null on T.
      return;
    }
    if (!safetyCenterManager.isSafetyCenterEnabled()) {
      // Preferably, no Safety Source code should be run if Safety Center is disabled.
      return;
    }
    resolveTheIssue();
    SafetyEvent resolveActionSafetyEvent =
        new SafetyEvent.Builder(SafetyEvent.SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED)
            .setSafetySourceIssueId("MyIssueId")
            .setSafetySourceIssueActionId("MyIssueActionId")
            .build();
    SafetySourceData dataWithoutTheIssue = …;
    // Set the data (or report an error with reportSafetySourceError and
    // SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED, if something went wrong).
    safetyCenterManager.setSafetySourceData("MySourceId", dataWithoutTheIssue, resolveActionSafetyEvent);
  }

  private void resolveTheIssue() {
    // Resolves the issue for the user. Given this a BroadcastReceiver, this should be a fast action.
    // Otherwise, a foreground service and PendingIntent.getService should be used instead (or a job
    // could be scheduled here, too).
  }
}

La misma instancia de BroadcastReceiver en el ejemplo anterior se declara en AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="…">
    <application>
    <!-- … -->
        <receiver android:name=".ResolveActionReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="my.package.name.MY_RESOLVING_ACTION"/>
            </intent-filter>
        </receiver>
    <!-- … -->
    </application>
</manifest>

Cómo responder a los rechazos de problemas

Puedes especificar una instancia PendingIntent que se pueda activar cuando se descarta una instancia SafetySourceIssue. Safety Center controla los siguientes rechazos de problemas:

  • Si una fuente envía un problema, el usuario puede descartarlo en la pantalla del Centro de seguridad presionando el botón de descarte (un botón con la letra X en la tarjeta de advertencia).
  • Cuando un usuario descarta un problema, si este persiste, no se mostrará nuevamente en la IU.
  • Los rechazos persistentes en un disco permanecen durante los reinicios del dispositivo.
  • Si la fuente de Safety Center deja de mostrar un problema y, luego, vuelve a mostrarlo más adelante, el problema reaparecerá. Esto permite situaciones en las que un usuario ve una advertencia, la descarta y, luego, realiza una acción que debería aliviar el problema, pero el usuario vuelve a hacer algo que causa un problema similar. En este punto, la tarjeta de advertencia debería volver a aparecer.
  • Las tarjetas de advertencia amarillas y rojas vuelven a aparecer cada 180 días, a menos que el usuario las haya descartado varias veces.

La fuente no debería necesitar comportamientos adicionales, a menos que se cumplan las siguientes condiciones:

  • La fuente intenta implementar este comportamiento de manera diferente. Por ejemplo, nunca vuelve a mostrar el problema.
  • La fuente intenta usar esto como una devolución de llamada, por ejemplo, para registrar la información.

Proporciona datos para varios usuarios o perfiles

La API de SafetyCenterManager se puede usar en todos los usuarios y perfiles. Para obtener más información, consulta Cómo compilar apps con reconocimiento de multiusuario. El objeto Context que proporciona SafetyCenterManager está asociado con una instancia de UserHandle, por lo que la instancia de SafetyCenterManager que se muestra interactúa con el Centro de seguridad de esa instancia de UserHandle. De forma predeterminada, Context se asocia con el usuario en ejecución, pero es posible crear una instancia para otro usuario si la app tiene los permisos INTERACT_ACROSS_USERS y INTERACT_ACROSS_USERS_FULL. En este ejemplo, se muestra cómo realizar una llamada entre usuarios o perfiles:

Context userContext = context.createContextAsUser(userHandle, 0);
SafetyCenterManager userSafetyCenterManager = userContext.getSystemService(SafetyCenterManager.class);
if (userSafetyCenterManager == null) {
  // Should not be null on T.
  return;
}
// Calls to userSafetyCenterManager will provide data for the given userHandle

Cada usuario del dispositivo puede tener varios perfiles administrados. El Centro de seguridad proporciona datos diferentes para cada usuario, pero combina los datos de todos los perfiles administrados asociados a un usuario determinado.

Cuando se establece profile="all_profiles" para la fuente en el archivo de configuración, ocurre lo siguiente:

  • Hay una entrada de IU para el usuario (perfil superior) y todos sus perfiles administrados asociados (que usan instancias de titleForWork).

  • El indicador de actualización o nuevo análisis se envía para el perfil superior y todos los perfiles administrados asociados. El receptor asociado se inicia para cada perfil y puede proporcionar los datos asociados directamente a SafetyCenterManager sin tener que realizar una llamada entre perfiles, a menos que el receptor o la app sean singleUser.

  • Se espera que la fuente proporcione datos al usuario y todos sus perfiles administrados. Los datos de cada entrada de la IU pueden ser diferentes según el perfil.

Prueba

Puedes acceder a ShadowSafetyCenterManager y usarlo en una prueba de Robolectric.

private static final String MY_SOURCE_ID = "MySourceId";

private final MyClass myClass = …;
private final SafetyCenterManager safetyCenterManager = getApplicationContext().getSystemService(SafetyCenterManager.class);

@Test
public void whenRefreshingData_providesDataToSafetyCenterForMySourceId() {
    shadowOf(safetyCenterManager).setSafetyCenterEnabled(true);
    setupDataForMyClass(…);

    myClass.refreshData();

    SafetySourceData expectedSafetySourceData = …;
    assertThat(safetyCenterManager.getSafetySourceData(MY_SOURCE_ID)).isEqualTo(expectedSafetySourceData);
    SafetyEvent expectedSafetyEvent = …;
    assertThat(shadowOf(safetyCenterManager).getLastSafetyEvent(MY_SOURCE_ID)).isEqualTo(expectedSafetyEvent);
}

Puedes escribir más pruebas de extremo a extremo (E2E), pero eso está fuera del alcance de esta guía. Para obtener más información sobre cómo escribir estas pruebas de E2E, consulta Pruebas de CTS (CtsSafetyCenterTestCases).

APIs de prueba y internas

Las APIs internas y de prueba son para uso interno, por lo que no se describen en detalle en esta guía. Sin embargo, es posible que extendamos algunas APIs internas en el futuro para permitir que los OEMs creen su propia IU a partir de ellas. Actualizaremos esta guía para brindar orientación sobre cómo usarlas.

Permisos

  • MANAGE_SAFETY_CENTER
    • internal|installer|role
    • Se usa para las APIs internas de Safety Center
    • Solo se otorga al PermissionController y a la shell.

App de Configuración

Redireccionamiento del Centro de seguridad

De forma predeterminada, se accede al Centro de seguridad a través de la app de Configuración con una nueva entrada Seguridad y privacidad. Si usas una app de Configuración diferente o si la modificaste, es posible que debas personalizar la forma en que se accede al Centro de seguridad.

Cuando Safety Center está habilitado, sucede lo siguiente:

  • La entrada heredada de Privacidad es un código oculto.
  • La entrada heredada de Seguridad es un código oculto.
  • Se agregó una nueva entrada Seguridad y privacidad código
  • Nueva entrada de Seguridad y privacidad redirecciona al código del Centro de seguridad
  • Las acciones de intent android.settings.PRIVACY_SETTINGS y android.settings.SECURITY_SETTINGS se redireccionan para abrir el Centro de seguridad (código: security, privacy).

Páginas de seguridad y privacidad avanzadas

La app de Configuración contiene parámetros de configuración adicionales en los títulos Más parámetros de configuración de seguridad y Más parámetros de configuración de privacidad, disponibles en el Centro de seguridad:

Fuentes de seguridad

Safety Center se integra en un conjunto específico de fuentes de seguridad que proporciona la app de Configuración:

  • Una fuente de seguridad de la pantalla de bloqueo verifica que esta se haya configurado con una contraseña (o alguna otra medida de seguridad) para garantizar que la información privada del usuario esté protegida del acceso externo.
  • Aparece una fuente de seguridad biométrica (oculta de forma predeterminada) para integrarse con un sensor de huellas dactilares o facial.

Se puede acceder al código fuente de estas fuentes de Safety Center a través de la búsqueda de código de Android. Si no se modifica la app de Configuración (no se realizan cambios en el nombre del paquete, el código fuente ni el código fuente relacionado con una pantalla de bloqueo y datos biométricos), esta integración debería funcionar de inmediato. De lo contrario, es posible que se requieran algunas modificaciones, como cambiar el archivo de configuración para cambiar el nombre del paquete de la app de Configuración y las fuentes que se integran con Safety Center, así como la integración. Para obtener más información, consulta Cómo actualizar el archivo de configuración y la configuración de integración.

Información acerca de PendingIntent

Si dependes de la integración existente del Centro de seguridad de la app de Configuración en Android 14 o versiones posteriores, se corrigió el error que se describe a continuación. No es necesario leer esta sección en este caso.

Cuando te asegures de que el error no existe, establece un valor de configuración de recursos booleanos XML en la app de Configuración config_isSafetyCenterLockScreenPendingIntentFixed en true para desactivar la solución en el Centro de seguridad.

Solución alternativa de PendingIntent

Este error se produce porque la configuración usa elementos adicionales de la instancia Intent para determinar qué fragmento abrir. Debido a que Intent#equals no tiene en cuenta los elementos adicionales de la instancia Intent, la instancia PendingIntent para el ícono del menú de ajustes y la entrada se consideran iguales y navegan a la misma IU (aunque su intención sea navegar a una IU diferente). Este problema se corrigió en una versión de QPR diferenciando las instancias de PendingIntent por código de solicitud. Como alternativa, esto se podría diferenciar con Intent#setId.

Fuentes de seguridad internas

Algunas fuentes de Safety Center son internas y se implementan en la app del sistema PermissionController dentro del módulo PermissionController. Estas fuentes se comportan como fuentes normales de Safety Center y no reciben ningún tratamiento especial. El código de estas fuentes está disponible a través de la Búsqueda de código fuente público de Android.

Estos son principalmente indicadores de privacidad, por ejemplo:

  • Accesibilidad
  • Cómo revocar automáticamente los permisos de las apps que no se usan
  • Acceso a la ubicación
  • Agente de escucha de notificaciones
  • Información sobre la política de trabajo