Interagir avec le Centre de sécurité

Redirection vers le Centre de sécurité

Toutes les applications peuvent ouvrir le centre de sécurité à l'aide du android.content.Intent.ACTION_SAFETY_CENTER action (valeur de chaîne android.intent.action.SAFETY_CENTER).

Pour ouvrir le Centre de sécurité, passez un appel depuis une instance Activity:

Intent openSafetyCenterIntent = new Intent(Intent.ACTION_SAFETY_CENTER);

startActivity(openSafetyCenterIntent);

Rediriger vers un problème spécifique

Il est également possible de rediriger l'utilisateur vers une fiche d'avertissement spécifique du centre de sécurité à l'aide de des extras d'intent spécifique. Ces extras ne sont pas destinés à être utilisés par des tiers. ils font partie de SafetyCenterManager, qui fait partie de @SystemApi. Uniquement les applications système peuvent accéder à ces extras.

Les extras d'intent qui redirigent une fiche d'avertissement spécifique:

  • EXTRA_SAFETY_SOURCE_ID
    • Valeur de chaîne: android.safetycenter.extra.SAFETY_SOURCE_ID
    • Type de chaîne: spécifie l'ID de la source de sécurité de la fiche d'avertissement
    • Obligatoire pour que la redirection vers le problème fonctionne
  • EXTRA_SAFETY_SOURCE_ISSUE_ID
    • Valeur de chaîne: android.safetycenter.extra.SAFETY_SOURCE_ISSUE_ID
    • Type de chaîne: spécifie l'ID de la fiche d'avertissement
    • Obligatoire pour que la redirection vers le problème fonctionne
  • EXTRA_SAFETY_SOURCE_USER_HANDLE
    • Valeur de chaîne: android.safetycenter.extra.SAFETY_SOURCE_USER_HANDLE
    • Type de UserHandle: spécifie UserHandle pour l'avertissement associé carte
    • Facultatif (par défaut, l'utilisateur actuel)

L'extrait de code ci-dessous peut être utilisé à partir d'une instance Activity pour ouvrir depuis l'écran du Centre de sécurité pour un problème spécifique:

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

Rediriger vers une sous-page spécifique (à partir d'Android 14)

Sur Android 14 ou version ultérieure, la page du centre de sécurité est divisée en plusieurs sous-pages représentant les différents SafetySourcesGroup (dans Android 13, elles sont affichées sous forme d'entrées réductibles).

Il est possible de rediriger vers une sous-page spécifique à l'aide de cet extra d'intent:

  • EXTRA_SAFETY_SOURCES_GROUP_ID
    • Valeur de chaîne: android.safetycenter.extra.SAFETY_SOURCES_GROUP_ID
    • Type de chaîne: spécifie l'ID de SafetySourcesGroup
    • Obligatoire pour que la redirection vers la sous-page fonctionne

L'extrait de code ci-dessous peut être utilisé à partir d'une instance Activity pour ouvrir l'écran du Centre de sécurité vers une sous-page spécifique:

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

startActivity(openSafetyCenterIntent);

Utiliser les API sources du centre de sécurité

Les API sources du centre de sécurité sont disponibles via SafetyCenterManager (qui est une @SystemApi). Le code de la surface d'API est disponible dans Code Rechercher. Le code d'implémentation des API est disponible dans la section Code Recherche.

Autorisations

Seules les applications système figurant sur la liste d'autorisation peuvent accéder aux API sources du centre de sécurité à l'aide des autorisations indiquées ci-dessous. Pour plus d'informations, reportez-vous à la section Ajout à la liste d'autorisation des autorisations

  • READ_SAFETY_CENTER_STATUS
    • signature|privileged
    • Utilisé pour l'API SafetyCenterManager#isSafetyCenterEnabled() (et non pour pour les sources du centre de sécurité, elles n'ont besoin Autorisation SEND_SAFETY_CENTER_UPDATE)
    • Utilisé par les applications système qui vérifient si le centre de sécurité est activé
    • Accordé uniquement aux applications système figurant sur la liste d'autorisation
  • SEND_SAFETY_CENTER_UPDATE
    • internal|privileged
    • Utilisé pour l'API activée et l'API Safety Sources
    • Utilisé par les sources de sécurité uniquement
    • Accordé uniquement aux applications système figurant sur la liste d'autorisation

Ces autorisations sont privilégiées et vous ne pouvez les acquérir qu'en les ajoutant à le fichier approprié, par exemple, com.android.settings.xml pour l'application Paramètres et au fichier AndroidManifest.xml de l'application. Voir protectionLevel pour en savoir plus sur le modèle d'autorisation.

Obtenir le SafetyCenterManager

SafetyCenterManager est une classe @SystemApi accessible depuis les applications système à partir d'Android 13. Cet appel montre comment téléchargez 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;
}

Vérifier si le Centre de sécurité est activé

Cet appel vérifie si le centre de sécurité est activé. L'appel requiert READ_SAFETY_CENTER_STATUS ou l'autorisation SEND_SAFETY_CENTER_UPDATE:

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

Fournir des données

Les données sources du centre de sécurité avec l'String sourceId donné sont fournies à l'outil Sécurité Centre avec l'objet SafetySourceData, qui représente une entrée d'interface utilisateur et une liste des problèmes (fiches d'avertissement). L'entrée de l'UI et les cartes d'avertissement peuvent avoir différents niveaux de gravité spécifiés dans la classe SafetySourceData:

  • SEVERITY_LEVEL_UNSPECIFIED
    • Aucun niveau de gravité spécifié
    • Couleur: gris ou transparent (selon le SafetySourcesGroup des entrée)
    • Utilisé pour les données dynamiques qui se présentent comme une entrée statique dans l'interface utilisateur ou pour afficher une entrée non spécifiée
    • Ne doit pas être utilisée pour les fiches d'avertissement
  • SEVERITY_LEVEL_INFORMATION
    • Informations de base ou suggestion mineure
    • Couleur: vert
  • SEVERITY_LEVEL_RECOMMENDATION
    • Recommandation à l'utilisateur de prendre des mesures concernant ce problème, car il pourrait les mettre en danger
    • Couleur: jaune
  • SEVERITY_LEVEL_CRITICAL_WARNING
    • Avertissement critique indiquant à l'utilisateur de prendre des mesures concernant ce problème, car il présente un risque
    • Couleur: rouge

SafetySourceData

L'objet SafetySourceData est composé d'une entrée d'interface utilisateur, de fiches d'avertissement et et invariantes.

  • Instance SafetySourceStatus facultative (entrée dans l'interface utilisateur)
  • Liste de SafetySourceIssue instances (fiches d'avertissement)
  • Bonus Bundle facultatifs (à partir de 14)
  • Invariantes: <ph type="x-smartling-placeholder">
      </ph>
    • La liste SafetySourceIssue doit être composée de problèmes avec des identifiants.
    • L'instance SafetySourceIssue ne doit pas être d'une importance supérieure à SafetySourceStatus s'il y en a une (sauf si SafetySourceStatus est SEVERITY_LEVEL_UNSPECIFIED, auquel cas SEVERITY_LEVEL_INFORMATION sont autorisés).
    • Les exigences supplémentaires imposées par la configuration de l'API doivent être respectées, Par exemple, si la source concerne uniquement un problème, elle ne doit pas fournir de Instance SafetySourceStatus.

SafetySourceStatus

  • Titre CharSequence obligatoire
  • Récapitulatif obligatoire pour CharSequence
  • Niveau de gravité requis
  • Facultatif PendingIntent pour rediriger l'utilisateur vers la bonne page (intentAction par défaut est utilisé). de la configuration, le cas échéant)
  • Élément IconAction facultatif (affiché sous la forme d'une icône latérale dans l'entrée) composé des éléments suivants:
    • Type d'icône obligatoire. Il doit s'agir de l'un des types suivants: <ph type="x-smartling-placeholder">
        </ph>
      • ICON_TYPE_GEAR: s'affiche sous la forme d'une roue dentée à côté de l'entrée de l'interface utilisateur.
      • ICON_TYPE_INFO: s'affiche sous la forme d'une icône d'informations à côté de l'entrée de l'interface utilisateur.
    • Obligatoire PendingIntent pour rediriger l'utilisateur vers une autre page
  • Valeur booléenne facultative enabled qui permet de marquer l'entrée d'UI comme il n'est donc pas cliquable (par défaut, true)
  • Invariantes: <ph type="x-smartling-placeholder">
      </ph>
    • Les instances PendingIntent doivent ouvrir une instance Activity.
    • Si l'entrée est désactivée, elle doit être désignée SEVERITY_LEVEL_UNSPECIFIED
    • Exigences supplémentaires imposées par la configuration de l'API.

SafetySourceIssue

  • Identifiant String unique obligatoire
  • Titre CharSequence obligatoire
  • Sous-titre CharSequence facultatif
  • Récapitulatif obligatoire pour CharSequence
  • Niveau de gravité requis
  • Catégorie de problème facultative. Il doit s'agir de l'une des catégories suivantes: <ph type="x-smartling-placeholder">
      </ph>
    • ISSUE_CATEGORY_DEVICE: le problème affecte l'appareil de l'utilisateur.
    • ISSUE_CATEGORY_ACCOUNT: le problème affecte les comptes de l'utilisateur.
    • ISSUE_CATEGORY_GENERAL: le problème affecte la sécurité générale de l'utilisateur. Il s'agit de l'option par défaut.
    • ISSUE_CATEGORY_DATA (à partir d'Android 14): Le problème affecte les données de l'utilisateur.
    • ISSUE_CATEGORY_PASSWORDS (À partir d'Android 14): Le problème affecte l'expérience de l'utilisateur mots de passe.
    • ISSUE_CATEGORY_PERSONAL_SAFETY (À partir d'Android 14): Le problème affecte la vie privée de l'utilisateur sécurité.
  • Liste des éléments Action que l'utilisateur peut utiliser pour ce problème, chacun Instance Action composée de:
    • Identifiant String unique obligatoire
    • Libellé CharSequence obligatoire
    • Obligatoire PendingIntent pour rediriger l'utilisateur vers une autre page ou pour traiter l'action directement à partir l'écran du Centre de sécurité
    • Booléen facultatif permettant de spécifier si ce problème peut être résolu directement à partir de l'écran SafetyCenter (false par défaut)
    • Message de réussite CharSequence facultatif à afficher pour l'utilisateur lorsque le problème est résolu directement depuis le centre de sécurité. écran
  • Facultatif PendingIntent qui est appelée lorsque l'utilisateur ignore le problème (par défaut, rien n'est appelé)
  • Identifiant obligatoire du type de problème (String). cela ressemble au problème mais qui n'a pas besoin d'être unique et est utilisé pour la journalisation
  • String facultatif pour l'ID de déduplication, permettant de publier les mêmes SafetySourceIssue provenant de différentes sources et n'apparaissent qu'une seule fois dans le UI en supposant qu'elles ont le même deduplicationGroup (à partir d'Android 14). S'il n'est pas spécifié, le problème n'est jamais dédupliqué
  • CharSequence facultatif pour le titre de l'attribution. Il s'agit d'un texte qui affiche d'où provient la fiche d'avertissement ( 14). S'il n'est pas spécifié, le titre de la SafetySourcesGroup
  • Action facultative sur le problème (à partir d'Android 14) qui doit être l'un des suivants: <ph type="x-smartling-placeholder">
      </ph>
    • ISSUE_ACTIONABILITY_MANUAL: l'utilisateur doit résoudre ce problème manuellement. Il s'agit de l'option par défaut.
    • ISSUE_ACTIONABILITY_TIP: ce problème n'est qu'un conseil et ne nécessite pas forcément toute entrée utilisateur.
    • ISSUE_ACTIONABILITY_AUTOMATIC: ce problème a déjà été résolu et ne nécessite aucune intervention de la part de l'utilisateur.
  • Comportement de notification facultatif (système d'exploitation Android 14), qui doit être l'une des valeurs suivantes: <ph type="x-smartling-placeholder">
      </ph>
    • NOTIFICATION_BEHAVIOR_UNSPECIFIED: le centre de sécurité décide si un est nécessaire pour la fiche d'avertissement. Il s'agit de l'option par défaut.
    • NOTIFICATION_BEHAVIOR_NEVER: aucune notification n'est publiée.
    • NOTIFICATION_BEHAVIOR_DELAYED: une notification sera publiée il y a quelque temps après le premier signalement du problème.
    • NOTIFICATION_BEHAVIOR_IMMEDIATELY: une notification est publiée dès que le problème est signalé.
  • Facultatif Notification, pour afficher une notification personnalisée avec la fiche d'avertissement (À partir d'Android 14) S'il n'est pas spécifié, le Notification est dérivé de la fiche d'avertissement. Composition de: <ph type="x-smartling-placeholder">
      </ph>
    • Titre CharSequence obligatoire
    • Récapitulatif obligatoire pour CharSequence
    • Liste des éléments Action que l'utilisateur peut utiliser pour cette notification
  • Invariantes: <ph type="x-smartling-placeholder">
      </ph>
    • La liste des instances Action doit être composée d'actions ayant des attributs identifiants
    • La liste des instances Action doit contenir une ou deux instances Action. éléments. Si l'exploitabilité n'est pas ISSUE_ACTIONABILITY_MANUAL, avoir une valeur Action nulle est autorisée.
    • L'élément OnDismiss PendingIntent ne doit pas ouvrir une instance Activity
    • Exigences supplémentaires imposées par la configuration de l'API

Les données sont fournies au centre de sécurité pour certains événements. Il est donc nécessaire de spécifier ce qui a amené la source à fournir à SafetySourceData SafetyEvent instance.

SafetyEvent

  • Type obligatoire, qui doit être l'un des suivants: <ph type="x-smartling-placeholder">
      </ph>
    • SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED: l'état de la source modifié.
    • SAFETY_EVENT_TYPE_REFRESH_REQUESTED: réponse à une actualisation/une nouvelle analyse le signal du Centre de sécurité ; utilisez ceci à la place de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED pour que le Centre de sécurité puisse suivre la demande d'actualisation/nouvelle analyse.
    • SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED: résolution SafetySourceIssue.Action directement depuis l'écran du Centre de sécurité ; utiliser ceci au lieu de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED pour des raisons de sécurité afin de pouvoir suivre la résolution du problème SafetySourceIssue.Action.
    • SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED: nous avons tenté de résoudre le problème SafetySourceIssue.Action directement sur l'écran du Centre de sécurité, mais n’a pas réussi à le faire ; utilisez ceci à la place de SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED pour que le Centre de sécurité puisse échec du canal SafetySourceIssue.Action.
    • SAFETY_EVENT_TYPE_DEVICE_LOCALE_CHANGED: langue de l'appareil a changé, nous modifions donc le texte des données fournies. il fait autorisé à utiliser SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED pour cela.
    • SAFETY_EVENT_TYPE_DEVICE_REBOOTED: nous fournissons ces données dans le cadre d'un démarrage initial, car les données du centre de sécurité ne sont pas conservées les redémarrages il est autorisé d'utiliser SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED pour cela.
  • Identifiant String facultatif pour l'ID de diffusion d'actualisation.
  • Identifiant String facultatif pour l'instance SafetySourceIssue qui récupère résolu.
  • Identifiant String facultatif pour l'instance SafetySourceIssue.Action résoudre le problème.
  • Invariantes: <ph type="x-smartling-placeholder">
      </ph>
    • L'ID de diffusion d'actualisation doit être fourni si le type est SAFETY_EVENT_TYPE_REFRESH_REQUESTED
    • Vous devez indiquer les ID du problème et de l'action si le type est : SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED ou SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED

Vous trouverez ci-dessous un exemple illustrant comment une source peut fournir des données au Centre de sécurité (dans ce s'il s'agit d'une entrée avec une seule fiche d'avertissement):

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

Obtenir les dernières données fournies

Vous pouvez obtenir les dernières données fournies au centre de sécurité pour une source appartenant à votre l'application. Vous pouvez l'utiliser pour afficher des éléments dans votre propre interface utilisateur, afin de vérifier si les données doit être mis à jour avant d'effectuer une opération coûteuse, ou pour fournir même instance SafetySourceData vers le centre de sécurité, en apportant quelques modifications ou en nouvelle instance SafetyEvent. Elle est également utile pour les tests.

Utilisez ce code pour obtenir les dernières données fournies au centre de sécurité:

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

Signaler une erreur

Si vous ne pouvez pas collecter de données sur SafetySourceData, vous pouvez signaler l'erreur à l'équipe Sécurité Center, ce qui change l'entrée en gris, efface les données mises en cache et fournit un Envoyez un message du type Impossible de vérifier le paramètre. Vous pouvez également signaler une erreur si la résolution d'une instance de SafetySourceIssue.Action échoue, auquel cas l'erreur les données mises en cache ne sont pas effacées et l'entrée de l'interface utilisateur n'est pas modifiée ; mais un message est est montré à l'utilisateur pour l'informer que quelque chose s'est mal passé.

Vous pouvez fournir l'erreur à l'aide de SafetySourceErrorDetails, qui est composé de:

  • SafetySourceErrorDetails: instance SafetyEvent requise:
// 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);

Répondre à une demande d'actualisation ou de nouvelle analyse

Vous pouvez recevoir un signal du centre de sécurité pour fournir de nouvelles données. Pour répondre à une une demande d'actualisation ou de nouvelle analyse garantit que l'utilisateur consulte l'état actuel qui ouvre le Centre de sécurité et quand il appuie sur le bouton de numérisation.

Cela se fait en recevant une annonce avec l'action suivante:

  • ACTION_REFRESH_SAFETY_SOURCES
    • Valeur de chaîne: android.safetycenter.action.REFRESH_SAFETY_SOURCES
    • Déclenché lorsque le centre de sécurité envoie une demande d'actualisation des données de la source de sécurité d'une application donnée ;
    • Intent protégé qui ne peut être envoyé que par le système
    • Envoyé à toutes les sources de sécurité du fichier de configuration en tant que fichier explicite et nécessite l'autorisation SEND_SAFETY_CENTER_UPDATE

Les extras suivants sont fournis dans le cadre de cette diffusion:

  • EXTRA_REFRESH_SAFETY_SOURCE_IDS
    • Valeur de chaîne: android.safetycenter.extra.REFRESH_SAFETY_SOURCE_IDS
    • Type de tableau de chaînes (String[]), qui représente les ID sources à actualiser l'application donnée

  • EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE

    • Valeur de chaîne: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_REQUEST_TYPE
    • Type "Entier", représente un type de requête @IntDef
    • Doit être l'un des suivants: <ph type="x-smartling-placeholder">
        </ph>
      • EXTRA_REFRESH_REQUEST_TYPE_GET_DATA: demande à la source de fournissent des données assez rapidement, généralement lorsque l'utilisateur ouvre la page ;
      • EXTRA_REFRESH_REQUEST_TYPE_FETCH_FRESH_DATA: demande la source. afin de fournir des données aussi récentes que possible, généralement lorsque l'utilisateur appuie sur le bouton de nouvelle recherche

  • EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID

    • Valeur de chaîne: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_BROADCAST_ID
    • Type de chaîne, représente un identifiant unique pour l'actualisation demandée

Pour recevoir un signal du centre de sécurité, implémentez une BroadcastReceiver Compute Engine. L'annonce est envoyée avec un BroadcastOptions spécial qui permet au pour démarrer un service de premier plan.

BroadcastReceiver répond à une requête d'actualisation:

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 même instance de BroadcastReceiver dans l'exemple ci-dessus est déclarée dans 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>

Dans l'idéal, la source du centre de sécurité doit être implémentée de manière à appeler SafetyCenterManager lorsque ses données changent. Pour des raisons d'état du système, recommandent de ne répondre qu'au signal de nouvelle recherche (lorsque l'utilisateur appuie sur la ), et non lorsque l'utilisateur ouvre le centre de sécurité. Si cette fonctionnalité est obligatoire, le champ refreshOnPageOpenAllowed="true" du fichier de configuration doit être défini pour que la source reçoive la diffusion dans ces cas.

Répondre au centre de sécurité si cette fonctionnalité est activée ou désactivée

Lorsque le centre de sécurité est activé ou désactivé, vous pouvez réagir en utilisant cette action d'intent:

  • ACTION_SAFETY_CENTER_ENABLED_CHANGED
    • Valeur de chaîne: android.safetycenter.action.SAFETY_CENTER_ENABLED_CHANGED
    • Déclenchement lorsque le centre de sécurité est activé ou désactivé alors que le l'appareil est en cours d'exécution
    • Non appelé au démarrage (utilisez ACTION_BOOT_COMPLETED pour cela)
    • Intent protégé qui ne peut être envoyé que par le système
    • Envoyé à toutes les sources de sécurité du fichier de configuration en tant que fichier explicite intent, nécessite l'autorisation SEND_SAFETY_CENTER_UPDATE.
    • Envoyé en tant qu'intent implicite qui nécessite READ_SAFETY_CENTER_STATUS autorisation

Cette action d'intent est utile pour activer ou désactiver des fonctionnalités liées à Centre de sécurité sur l'appareil.

Implémenter des actions de résolution

Une action de résolution est une instance SafetySourceIssue.Action qu'un utilisateur peut résoudre directement depuis l'écran du Centre de sécurité. L'utilisateur appuie sur un bouton d'action et l'instance PendingIntent sur SafetySourceIssue.Action envoyée par source de sécurité est déclenchée, ce qui résout le problème en arrière-plan et envoie une notification au centre de sécurité une fois l'opération terminée.

Pour implémenter des actions de résolution, la source du centre de sécurité peut utiliser un service si : l'opération devrait prendre un certain temps (PendingIntent.getService) ou une un broadcast receiver (PendingIntent.getBroadcast).

Utilisez ce code pour envoyer un problème de résolution au centre de sécurité:

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 résout l'action:

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 même instance de BroadcastReceiver dans l'exemple ci-dessus est déclarée dans 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>

Répondre aux problèmes de refus

Vous pouvez spécifier une instance PendingIntent qui peut être déclenchée lorsqu'un L'instance SafetySourceIssue est fermée. Le centre de sécurité gère ces problèmes abandons:

  • Si une source signale un problème, un utilisateur peut l'ignorer dans le Centre de sécurité en appuyant sur le bouton "Ignorer" (un bouton X sur la fiche d'avertissement).
  • Lorsqu'un utilisateur ignore un problème, il n'est pas visible s'il persiste. dans l'interface utilisateur.
  • Les fermetures persistantes sur un disque persistent pendant le redémarrage de l'appareil.
  • Si la source du centre de sécurité cesse de signaler un problème, puis indique le problème à nouveau ultérieurement, le problème réapparaît. Cela permet de lorsqu'un utilisateur voit un avertissement, le ferme, puis prend les mesures nécessaires doit atténuer le problème, mais l'utilisateur fait à nouveau quelque chose qui entraîne un problème similaire. La carte d'avertissement devrait alors réapparaître.
  • Les cartes d'avertissement jaunes et rouges réapparaissent tous les 180 jours, sauf si l'utilisateur a les a ignorés plusieurs fois.

La source n'a pas besoin de comportements supplémentaires, sauf dans les cas suivants:

  • La source tente d'implémenter ce comportement différemment. Par exemple, ne jamais faire réapparaître le problème.
  • La source tente de l'utiliser comme rappel, par exemple pour consigner des informations.

Fournir des données pour plusieurs utilisateurs/profils

L'API SafetyCenterManager peut être utilisée pour plusieurs utilisateurs et profils. Pour plus en savoir plus, consultez la page Building Multiuser-Aware Applications. Context qui fournit SafetyCenterManager est associé à un UserHandle L'instance SafetyCenterManager renvoyée interagit donc avec l'instance Centre de sécurité pour cette instance UserHandle. Par défaut, Context est associé à l'utilisateur en cours d'exécution, mais il est possible de créer une instance un autre utilisateur si l'application contient INTERACT_ACROSS_USERS et Autorisations INTERACT_ACROSS_USERS_FULL. Cet exemple montre comment passer un appel pour plusieurs utilisateurs/profils:

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

Chaque utilisateur de l'appareil peut disposer de plusieurs profils gérés. Centre de sécurité fournit des données différentes pour chaque utilisateur, mais fusionne les données de toutes les de profils associés à un utilisateur donné.

Lorsque profile="all_profiles" est défini pour la source dans le fichier de configuration, voici ce qui se produit:

  • Une entrée d'UI est créée pour l'utilisateur (parent de profil) et toutes les entrées associées les profils gérés (qui utilisent des instances titleForWork).

  • Le signal d'actualisation ou de nouvelle analyse est envoyé au parent du profil et à toutes les profils gérés associés. Le récepteur associé est démarré pour chaque et peut fournir les données associées directement SafetyCenterManager sans avoir à effectuer d'appel dans tous les profils, sauf si le ou l'application est singleUser

  • La source doit fournir des données à l'utilisateur et à toutes ses ressources profils. Les données pour chaque entrée de l'interface utilisateur peuvent varier en fonction de la profil.

Tests

vous pouvez accéder à ShadowSafetyCenterManager et l'utiliser dans un test 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);
}

Vous pouvez écrire plus de tests de bout en bout (E2E), mais cela sort du cadre . Pour en savoir plus sur l'écriture de ces tests E2E, consultez la section Tests CTS. (CtsSafetyCenterTestCases).

API de test et API internes

Les API internes et les API de test sont destinées à un usage interne et ne sont donc pas décrites dans en détail dans ce guide. Toutefois, il se peut que nous étendions certaines API internes à l'avenir. pour permettre aux OEM de créer leur propre interface utilisateur. Nous mettrons à jour ce guide pour vous des conseils sur la façon de les utiliser.

Autorisations

  • MANAGE_SAFETY_CENTER
    • internal|installer|role
    • Utilisé pour les API internes du centre de sécurité
    • Accordé uniquement à PermissionController et à l'interface système

Application Paramètres

Redirection du centre de sécurité

Par défaut, vous accédez au Centre de sécurité via l'application Paramètres avec un nouveau Sécurité et la confidentialité. Si vous utilisez une autre application Paramètres ou si vous avez modifié l'application Paramètres, vous devrez peut-être personnaliser la façon dont le Centre de sécurité est accessible.

Lorsque le centre de sécurité est activé:

  • L'ancienne entrée Privacy est masquée code
  • L'ancienne entrée Security est un code masqué
  • Nouveaux paramètres de sécurité et confidentialité est ajouté code
  • Nouveaux paramètres de sécurité et privacy redirige vers le code du centre de sécurité
  • android.settings.PRIVACY_SETTINGS et android.settings.SECURITY_SETTINGS les actions d'intent sont redirigées vers le centre de sécurité ouvert (code: la sécurité, confidentialité)

Pages "Sécurité et confidentialité" avancées

L'application Paramètres contient des paramètres supplémentaires sous Autres paramètres de sécurité. et Autres paramètres de confidentialité, disponibles dans le Centre de sécurité:

Sources de sécurité

Le centre de sécurité s'intègre à un ensemble spécifique de sources de sécurité fournies par le Application Paramètres:

  • Une source de sécurité de l'écran de verrouillage vérifie qu'un écran de verrouillage est configuré avec un (ou un autre type de sécurité), afin de garantir que les informations privées de l'utilisateur est protégé des accès externes.
  • Une source de sécurité biométrique (masquée par défaut) présente des surfaces à intégrer à un le lecteur d'empreinte digitale ou de visage.

Le code source de ces sources du Centre de sécurité est accessible via Android coder le Réseau de Recherche. Si l'application Paramètres n'est pas modifiée (le nom du package n'est pas modifié, le code source ou le code source qui gère l'écran de verrouillage et la biométrie), cette intégration devrait fonctionner immédiatement. Sinon, certaines modifications peut être nécessaire, comme modifier le fichier de configuration pour changer le package nom de l'application Paramètres et des sources qui s'intègrent au Centre de sécurité, comme ainsi que l'intégration. Pour en savoir plus, consultez la section Mettre à jour la configuration fichier et intégration paramètres.

À propos de PendingIntent

Si vous utilisez l'intégration existante du centre de sécurité dans l'application Paramètres sur Android 14 ou version ultérieure, le bug décrit ci-dessous a été corrigé. La lecture de cette section n'est pas nécessaire dans ce cas.

Lorsque vous êtes certain que le bug n'existe pas, définissez une ressource XML booléenne valeur de configuration dans l'application Paramètres config_isSafetyCenterLockScreenPendingIntentFixed sur true pour désactiver dans le Centre de sécurité.

Solution de contournement avec PendingIntent

Ce bug est dû au fait que les paramètres utilisent les extras d'instance Intent pour déterminer quelle instance fragment pour l'ouvrir. Comme Intent#equals ne prend pas l'instance Intent en compte, l'instance PendingIntent pour l'icône de menu en forme de roue dentée et sont considérées comme égales et permettent d'accéder à la même interface utilisateur (même si elles sont destinés à accéder à une autre interface utilisateur). Ce problème est résolu dans une version QPR en différenciant les instances PendingIntent par un code de requête. Par ailleurs, cela peut être différencié à l'aide de Intent#setId.

Sources de sécurité internes

Certaines sources du centre de sécurité sont internes et sont implémentées dans le Application système PermissionController dans le module PermissionController. Ces se comportent comme les sources habituelles du centre de sécurité et ne reçoivent pas de traitement. Le code de ces sources est disponible via le code Android le Réseau de Recherche.

Il s'agit principalement de signaux de confidentialité. Par exemple:

  • Accessibilité
  • Révoquer automatiquement les applications inutilisées
  • Accès à la position
  • Outil d'écoute des notifications
  • Infos sur les règles professionnelles