Mit dem Sicherheitscenter interagieren

Weiterleitung zum Sicherheitscenter

Jede App kann das Sicherheitscenter über die Aktion android.content.Intent.ACTION_SAFETY_CENTER (Stringwert android.intent.action.SAFETY_CENTER) öffnen.

So öffnen Sie das Sicherheitscenter:Activity

Intent openSafetyCenterIntent = new Intent(Intent.ACTION_SAFETY_CENTER);

startActivity(openSafetyCenterIntent);

Zu einem bestimmten Problem weiterleiten

Mithilfe bestimmter Intent-Extras ist es auch möglich, zu einer bestimmten Warnkarte des Google Unternehmensprofils weiterzuleiten. Diese Extras sind nicht für die Verwendung durch Dritte gedacht. Sie sind Teil von SafetyCenterManager, das zu @SystemApi gehört. Nur System-Apps können auf diese Extras zugreifen.

Intent-Extras, die zu einer bestimmten Warnkarte weiterleiten:

• EXTRA_SAFETY_SOURCE_ID
  • Stringwert: android.safetycenter.extra.SAFETY_SOURCE_ID
  • Stringtyp: Gibt die ID der Sicherheitsquelle der zugehörigen Warnkarte an.
  • Erforderlich, damit die Weiterleitung zum Problem funktioniert
• EXTRA_SAFETY_SOURCE_ISSUE_ID
  • Stringwert: android.safetycenter.extra.SAFETY_SOURCE_ISSUE_ID
  • Stringtyp: Gibt die ID der Warnkarte an.
  • Erforderlich, damit die Weiterleitung zum Problem funktioniert
• EXTRA_SAFETY_SOURCE_USER_HANDLE
  • Stringwert: android.safetycenter.extra.SAFETY_SOURCE_USER_HANDLE
  • UserHandle-Typ: Gibt UserHandle für die zugehörige Warnkarte an.
  • Optional (Standard ist „aktueller Nutzer“)

Mit dem folgenden Code-Snippet können Sie in einer Activity-Instanz den Bildschirm „Sicherheitscenter“ für ein bestimmtes Problem öffnen:

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

Auf eine bestimmte Unterseite weiterleiten (ab Android 14)

Unter Android 14 oder höher ist die Seite „Sicherheitscenter“ in mehrere Unterseiten unterteilt, die die verschiedenen SafetySourcesGroup darstellen. Unter Android 13 werden diese als minimierbare Einträge angezeigt.

Mit diesem Intent-Extra können Sie zu einer bestimmten Unterseite weiterleiten:

• EXTRA_SAFETY_SOURCES_GROUP_ID
  • Stringwert: android.safetycenter.extra.SAFETY_SOURCES_GROUP_ID
  • Stringtyp: Gibt die ID des SafetySourcesGroup
  • Erforderlich, damit die Weiterleitung zur Unterseite funktioniert

Mit dem folgenden Code-Snippet können Sie in einer Activity-Instanz den Bildschirm „Sicherheitscenter“ mit einer bestimmten Unterseite öffnen:

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

startActivity(openSafetyCenterIntent);

Quell-APIs des Safety Centers verwenden

Die Safety Center-Quell-APIs sind über SafetyCenterManager (eine @SystemApi) verfügbar. Code für die API-Oberfläche ist in der Code Search verfügbar. Der Implementierungscode der APIs ist in der Code Search verfügbar.

Berechtigungen

Auf die Safety Center-Quell-APIs kann nur mit den unten aufgeführten Berechtigungen zugegriffen werden. Weitere Informationen finden Sie unter Zulassungsliste für Berechtigungen mit erhöhten Berechtigungen.

• READ_SAFETY_CENTER_STATUS
  • signature|privileged
  • Wird für die SafetyCenterManager#isSafetyCenterEnabled() API verwendet (nicht für Safety Center-Quellen erforderlich, für diese ist nur die Berechtigung SEND_SAFETY_CENTER_UPDATE erforderlich)
  • Wird von System-Apps verwendet, die prüfen, ob das Sicherheitscenter aktiviert ist
  • Nur für System-Apps auf der Zulassungsliste gewährt
• SEND_SAFETY_CENTER_UPDATE
  • internal|privileged
  • Wird für die aktivierte API und die Safety Sources API verwendet
  • Nur von Sicherheitsquellen verwendet
  • Nur für System-Apps auf der Zulassungsliste gewährt

Diese Berechtigungen sind privilegiert und Sie können sie nur erhalten, indem Sie sie der entsprechenden Datei hinzufügen, z. B. der Datei com.android.settings.xml für die Einstellungen App und der Datei AndroidManifest.xml der App. Weitere Informationen zum Berechtigungsmodell finden Sie unter protectionLevel.

SafetyCenterManager abrufen

SafetyCenterManager ist eine @SystemApi-Klasse, auf die ab Android 13 über System-Apps zugegriffen werden kann. In diesem Aufruf wird gezeigt, wie Sie SafetyCenterManager abrufen:

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

Prüfen, ob das Sicherheitscenter aktiviert ist

Mit diesem Aufruf wird geprüft, ob das Sicherheitscenter aktiviert ist. Für den Aufruf ist entweder die Berechtigung READ_SAFETY_CENTER_STATUS oder SEND_SAFETY_CENTER_UPDATE erforderlich:

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

Daten angeben

Safety Center-Quelldaten mit der angegebenen String sourceId werden dem Safety Center mit dem SafetySourceData-Objekt bereitgestellt. Dieses Objekt stellt einen UI-Eintrag und eine Liste von Problemen (Warnkarten) dar. Der UI-Eintrag und die Warnkarten können unterschiedliche Schweregrade haben, die in der SafetySourceData-Klasse angegeben sind:

• SEVERITY_LEVEL_UNSPECIFIED
  • Schweregrad nicht angegeben
  • Farbe: Grau oder transparent (je nach SafetySourcesGroup des Eintrags)
  • Wird für dynamische Daten verwendet, die als statischer Eintrag in der Benutzeroberfläche angezeigt werden, oder um einen nicht angegebenen Eintrag zu zeigen.
  • Darf nicht für Warnkarten verwendet werden
• SEVERITY_LEVEL_INFORMATION
  • Allgemeine Informationen oder kleinere Vorschläge
  • Farbe: Grün
• SEVERITY_LEVEL_RECOMMENDATION
  • Empfehlung, dass der Nutzer Maßnahmen zu diesem Problem ergreifen sollte, da er dadurch gefährdet sein könnte
  • Farbe: Gelb
• SEVERITY_LEVEL_CRITICAL_WARNING
  • Eine kritische Warnung, dass der Nutzer Maßnahmen ergreifen muss, da ein Risiko besteht
  • Farbe: Rot

SafetySourceData

Das SafetySourceData-Objekt besteht aus einem UI-Eintrag, Warnkarten und Invarianten.

• Optionale SafetySourceStatus-Instanz (UI-Eintrag)
• Liste der SafetySourceIssue-Instanzen (Warnkarten)
• Optionale Bundle-Extras (ab Version 14)
• Invarianten:
  • Die SafetySourceIssue-Liste muss aus Problemen mit eindeutigen IDs bestehen.
  • Die SafetySourceIssue-Instanz darf nicht wichtiger sein als SafetySourceStatus, falls vorhanden. Dies gilt nicht, wenn SafetySourceStatus SEVERITY_LEVEL_UNSPECIFIED ist. In diesem Fall sind SEVERITY_LEVEL_INFORMATION-Probleme zulässig.
  • Zusätzliche Anforderungen der API-Konfiguration müssen erfüllt sein. Wenn die Quelle beispielsweise nur Probleme enthält, darf sie keine SafetySourceStatus-Instanz bereitstellen.

SafetySourceStatus

• Erforderlicher CharSequence-Titel
• Zusammenfassung der erforderlichen CharSequence
• Erforderlicher Schweregrad
• Optionale PendingIntent-Instanz, um den Nutzer zur richtigen Seite weiterzuleiten (standardmäßig wird intentAction aus der Konfiguration verwendet, falls vorhanden)
• Optional: IconAction (als Seitensymbol im Eintrag angezeigt) mit folgenden Elementen:
  • Erforderlicher Symboltyp, der einen der folgenden Typen haben muss:
    • ICON_TYPE_GEAR: Wird als Zahnrad neben dem UI-Eintrag angezeigt
    • ICON_TYPE_INFO: Wird als Informationssymbol neben dem UI-Eintrag angezeigt
  • Erforderlich, um den Nutzer zu einer anderen Seite weiterzuleiten PendingIntent
• Optionaler boolescher Wert enabled, mit dem der UI-Eintrag als deaktiviert markiert werden kann, sodass er nicht angeklickt werden kann (Standardwert ist true)
• Invarianten:
  • PendingIntent-Instanzen müssen eine Activity-Instanz öffnen.
  • Wenn der Eintrag deaktiviert ist, muss er als SEVERITY_LEVEL_UNSPECIFIED gekennzeichnet sein.
  • Zusätzliche Anforderungen, die durch die API-Konfiguration auferlegt werden.

SafetySourceIssue

• Erforderliche eindeutige String-Kennung
• Erforderlicher CharSequence-Titel
• Optionaler CharSequence-Untertitel
• Zusammenfassung der erforderlichen CharSequence
• Erforderlicher Schweregrad
• Optionale Problemkategorie, die eine der folgenden sein muss:
  • ISSUE_CATEGORY_DEVICE: Das Problem betrifft das Gerät des Nutzers.
  • ISSUE_CATEGORY_ACCOUNT: Das Problem betrifft die Konten des Nutzers.
  • ISSUE_CATEGORY_GENERAL: Das Problem wirkt sich auf die allgemeine Sicherheit des Nutzers aus. Das ist die Standardeinstellung.
  • ISSUE_CATEGORY_DATA (ab Android 14): Das Problem wirkt sich auf die Daten des Nutzers aus.
  • ISSUE_CATEGORY_PASSWORDS (ab Android 14): Das Problem betrifft die Passwörter der Nutzer.
  • ISSUE_CATEGORY_PERSONAL_SAFETY (ab Android 14): Das Problem wirkt sich auf die persönliche Sicherheit des Nutzers aus.
• Liste der Action-Elemente, die der Nutzer für dieses Problem ergreifen kann. Jede Action-Instanz besteht aus:
  • Erforderliche eindeutige String-Kennung
  • Erforderliches CharSequence-Label
  • Erforderlich, um den Nutzer auf eine andere Seite weiterzuleiten oder die Aktion direkt über den Bildschirm „Sicherheitscenter“ zu verarbeiten PendingIntent
  • Optionaler boolescher Wert, der angibt, ob dieses Problem direkt über den Bildschirm „Sicherheitscenter“ behoben werden kann (Standardwert: false)
  • Optionale CharSequence-Erfolgsmeldung, die dem Nutzer angezeigt wird, wenn das Problem direkt auf dem Bildschirm des Sicherheitscenters behoben wurde
• Optionale PendingIntent, die aufgerufen wird, wenn der Nutzer das Problem schließt (Standardeinstellung: nichts wird aufgerufen)
• Erforderliche String-ID für den Problemtyp; ähnelt der Problem-ID, muss aber nicht eindeutig sein und wird für die Protokollierung verwendet
• Optionale String für die Deduplizierungs-ID. Damit kann dieselbe SafetySourceIssue aus verschiedenen Quellen gepostet und nur einmal in der Benutzeroberfläche angezeigt werden, vorausgesetzt, sie hat dieselbe deduplicationGroup (ab Android 14). Wenn keine Angabe erfolgt, wird das Problem nie dedupliziert.
• Optional: CharSequence für den Titel der Attribution. Dies ist ein Text, der angibt, woher die Warnkarte stammt (ab Android 14). Wenn nicht angegeben, wird der Titel der SafetySourcesGroup verwendet.
• Optionale Maßnahmen für das Problem (ab Android 14), die eine der folgenden Optionen sein müssen:
  • ISSUE_ACTIONABILITY_MANUAL: Der Nutzer muss dieses Problem manuell beheben. Das ist die Standardeinstellung.
  • ISSUE_ACTIONABILITY_TIP: Dieses Problem ist nur ein Tipp und erfordert möglicherweise keine Nutzereingaben.
  • ISSUE_ACTIONABILITY_AUTOMATIC: Dieses Problem wurde bereits behoben und erfordert möglicherweise keine Nutzereingaben.
• Optionales Benachrichtigungsverhalten (ab Android 14), muss eine der folgenden Optionen sein:
  • NOTIFICATION_BEHAVIOR_UNSPECIFIED: Das Sicherheitscenter entscheidet, ob für die Warnkarte eine Benachrichtigung erforderlich ist. Das ist die Standardeinstellung.
  • NOTIFICATION_BEHAVIOR_NEVER: Es wird keine Benachrichtigung gepostet.
  • NOTIFICATION_BEHAVIOR_DELAYED: Eine Benachrichtigung wird einige Zeit nach der Erstmeldung des Problems veröffentlicht.
  • NOTIFICATION_BEHAVIOR_IMMEDIATELY: Sobald das Problem gemeldet wurde, wird eine Benachrichtigung gepostet.
• Optional: Notification, um eine benutzerdefinierte Benachrichtigung mit der Warnkarte anzuzeigen (ab Android 14). Wenn keine Angabe erfolgt, wird Notification aus der Warnkarte abgeleitet. Zusammensetzung:
  • Erforderlicher CharSequence-Titel
  • Zusammenfassung der erforderlichen CharSequence
  • Liste der Action-Elemente, die der Nutzer für diese Benachrichtigung ausführen kann
• Invarianten:
  • Die Liste der Action-Instanzen muss aus Aktionen mit eindeutigen IDs bestehen.
  • Die Liste der Action-Instanzen muss entweder ein oder zwei Action-Elemente enthalten. Wenn die Aktionsfähigkeit nicht ISSUE_ACTIONABILITY_MANUAL ist, ist es zulässig, dass Action = 0 ist.
  • Die OnDismiss-PendingIntent darf keine Activity-Instanz öffnen.
  • Zusätzliche Anforderungen durch die API-Konfiguration

Daten werden bei bestimmten Ereignissen an das Safety Center gesendet. Daher müssen Sie angeben, was dazu geführt hat, dass die Quelle SafetySourceData eine SafetyEvent-Instanz zur Verfügung gestellt hat.

SafetyEvent

• Erforderlicher Typ, der einer der folgenden sein muss:
  • SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED: Der Status der Quelle hat sich geändert.
  • SAFETY_EVENT_TYPE_REFRESH_REQUESTED: Antwortet auf ein Signal zum Aktualisieren/Neuscannen vom Safety Center. Verwenden Sie diese Option anstelle von SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED, damit das Safety Center die Aktualisierungs-/Neuscananfrage verfolgen kann.
  • SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED: Wir haben SafetySourceIssue.Action direkt über den Bildschirm des Sicherheitscenters behoben. Verwenden Sie diese ID anstelle von SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED für das Sicherheitscenter, damit wir die Behebung von SafetySourceIssue.Action verfolgen können.
  • SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED: Wir haben versucht, SafetySourceIssue.Action direkt über den Bildschirm des Sicherheitscenters zu beheben, konnten das Problem jedoch nicht beheben. Verwenden Sie diese ID anstelle von SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED, damit das Sicherheitscenter erkennen kann, dass SafetySourceIssue.Action fehlgeschlagen ist.
  • SAFETY_EVENT_TYPE_DEVICE_LOCALE_CHANGED: Die Sprache des Geräts hat sich geändert. Wir aktualisieren daher den Text der bereitgestellten Daten. Dazu ist es zulässig, SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED zu verwenden.
  • SAFETY_EVENT_TYPE_DEVICE_REBOOTED: Wir stellen diese Daten beim ersten Start bereit, da die Daten des Sicherheitscenters nicht nach einem Neustart beibehalten werden. Es ist zulässig, SAFETY_EVENT_TYPE_SOURCE_STATE_CHANGED dafür zu verwenden.
• Optionale String-ID für die Aktualisierungs-Broadcast-ID.
• Optionale String-ID für die zu bearbeitende SafetySourceIssue-Instanz.
• Optionale String-ID für die SafetySourceIssue.Action-Instanz, die behoben wird.
• Invarianten:
  • Die ID der Aktualisierungsübertragung muss angegeben werden, wenn der Typ SAFETY_EVENT_TYPE_REFRESH_REQUESTED ist.
  • Die Problem- und Aktions-IDs müssen angegeben werden, wenn der Typ SAFETY_EVENT_TYPE_RESOLVING_ACTION_SUCCEEDED oder SAFETY_EVENT_TYPE_RESOLVING_ACTION_FAILED ist.

Unten sehen Sie ein Beispiel dafür, wie eine Quelle Daten an das Safety Center senden kann. In diesem Fall wird ein Eintrag mit einer einzelnen Warnkarte bereitgestellt:

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

Letzte bereitgestellten Daten abrufen

Sie können die letzten Daten abrufen, die für eine Quelle, die zu Ihrer App gehört, an das Safety Center gesendet wurden. So können Sie etwas in Ihrer eigenen Benutzeroberfläche anzeigen, prüfen, ob die Daten vor der Ausführung eines ressourcenintensiven Vorgangs aktualisiert werden müssen, oder dieselbe SafetySourceData-Instanz mit einigen Änderungen oder mit einer neuen SafetyEvent-Instanz an das Safety Center senden. Außerdem ist es nützlich für Tests.

Mit diesem Code können Sie die letzten Daten abrufen, die an das Safety Center gesendet wurden:

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

Fehler melden

Wenn Sie keine SafetySourceData-Daten erheben können, können Sie den Fehler im Safety Center melden. Dadurch wird der Eintrag ausgegraut, die im Cache gespeicherten Daten werden gelöscht und eine Meldung wie Einstellung konnte nicht geprüft werden wird angezeigt. Sie können auch einen Fehler melden, wenn eine Instanz von SafetySourceIssue.Action nicht aufgelöst werden kann. In diesem Fall werden die im Cache gespeicherten Daten nicht gelöscht und der Eintrag in der Benutzeroberfläche nicht geändert. Der Nutzer wird jedoch über eine Meldung darüber informiert, dass ein Fehler aufgetreten ist.

Sie können den Fehler mit SafetySourceErrorDetails angeben, das aus folgenden Elementen besteht:

• SafetySourceErrorDetails: Erforderliche SafetyEvent-Instanz:

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

Auf eine Aktualisierungs- oder Neuabfrage reagieren

Sie können vom Sicherheitscenter eine Benachrichtigung erhalten, dass Sie neue Daten angeben müssen. Wenn Sie auf eine Aktualisierungs- oder Neuabfrage reagieren, sieht der Nutzer den aktuellen Status, wenn er das Sicherheitscenter öffnet und auf die Schaltfläche „Scannen“ tippt.

Dazu wird eine Übertragung mit der folgenden Aktion empfangen:

• ACTION_REFRESH_SAFETY_SOURCES
  • Stringwert: android.safetycenter.action.REFRESH_SAFETY_SOURCES
  • Wird ausgelöst, wenn das Safety Center eine Anfrage zum Aktualisieren der Daten der Sicherheitsquelle für eine bestimmte App sendet.
  • Geschützte Intents, die nur vom System gesendet werden können
  • Wird als explizite Absicht an alle Sicherheitsquellen in der Konfigurationsdatei gesendet und erfordert die Berechtigung SEND_SAFETY_CENTER_UPDATE.

Im Rahmen dieser Übertragung werden die folgenden Extras bereitgestellt:

• EXTRA_REFRESH_SAFETY_SOURCE_IDS
  • Stringwert: android.safetycenter.extra.REFRESH_SAFETY_SOURCE_IDS
  • Stringarraytyp (String[]) für die Quell-IDs, die für die jeweilige App aktualisiert werden sollen

• EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE

  • Stringwert: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_REQUEST_TYPE
  • Ganzzahltyp, stellt einen Anfragetyp dar @IntDef
  • Muss einer der folgenden Werte sein:
    • EXTRA_REFRESH_REQUEST_TYPE_GET_DATA: Die Quelle wird aufgefordert, relativ schnell Daten bereitzustellen, in der Regel, wenn der Nutzer die Seite öffnet.
    • EXTRA_REFRESH_REQUEST_TYPE_FETCH_FRESH_DATA: Die Quelle wird aufgefordert, möglichst aktuelle Daten bereitzustellen, in der Regel, wenn der Nutzer die Schaltfläche „Neuer Scan“ drückt.

• EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID

  • Stringwert: android.safetycenter.extra.REFRESH_SAFETY_SOURCES_BROADCAST_ID
  • Stringtyp, stellt eine eindeutige Kennung für die angeforderte Aktualisierung dar

Wenn du ein Signal vom Sicherheitscenter erhalten möchtest, musst du eine BroadcastReceiver-Instanz implementieren. Der Broadcast wird mit einem speziellen BroadcastOptions gesendet, mit dem der Empfänger einen Dienst im Vordergrund starten kann.

BroadcastReceiver antwortet auf eine Aktualisierungsanfrage:

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

Die gleiche Instanz von BroadcastReceiver im obigen Beispiel wird in AndroidManifest.xml deklariert:

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

Idealerweise ist eine Safety Center-Quelle so implementiert, dass sie SafetyCenterManager aufruft, wenn sich ihre Daten ändern. Aus Gründen der Systemintegrität empfehlen wir, nur auf das Signal für die erneute Suche zu reagieren (wenn der Nutzer auf die Schaltfläche „Scannen“ tippt), nicht aber, wenn der Nutzer das Sicherheitscenter öffnet. Wenn diese Funktion erforderlich ist, muss das Feld refreshOnPageOpenAllowed="true" in der Konfigurationsdatei für die Quelle festgelegt werden, damit sie die in diesen Fällen gesendeten Übertragungen empfängt.

Auf das Sicherheitscenter reagieren, wenn es aktiviert oder deaktiviert ist

Mit dieser Intent-Aktion können Sie reagieren, wenn der Dienst „Sicherheitscenter“ aktiviert oder deaktiviert ist:

• ACTION_SAFETY_CENTER_ENABLED_CHANGED
  • Stringwert: android.safetycenter.action.SAFETY_CENTER_ENABLED_CHANGED
  • Wird ausgelöst, wenn das Sicherheitscenter während der Laufzeit des Geräts aktiviert oder deaktiviert wird
  • Wird beim Starten nicht aufgerufen (verwenden Sie dazu ACTION_BOOT_COMPLETED).
  • Geschützte Intents, die nur vom System gesendet werden können
  • Wird als explizite Absicht an alle Sicherheitsquellen in der Konfigurationsdatei gesendet. Erfordert die Berechtigung SEND_SAFETY_CENTER_UPDATE.
  • Als impliziter Intent gesendet, für den die Berechtigung READ_SAFETY_CENTER_STATUS erforderlich ist

Mit dieser Intent-Aktion können Sie Funktionen aktivieren oder deaktivieren, die sich auf den Dienst „Sicherheitscenter“ auf dem Gerät beziehen.

Maßnahmen zur Problembehebung implementieren

Eine Behebungsaktion ist eine SafetySourceIssue.Action-Instanz, die ein Nutzer direkt über den Bildschirm des Sicherheitscenters beheben kann. Der Nutzer tippt auf eine Aktionsschaltfläche und die von der Sicherheitsquelle gesendete PendingIntent-Instanz auf SafetySourceIssue.Action wird ausgelöst. Dadurch wird das Problem im Hintergrund behoben und das Sicherheitscenter wird benachrichtigt, wenn die Lösung abgeschlossen ist.

Zur Implementierung von Maßnahmen zur Problembehebung kann die Safety Center-Quelle einen Dienst verwenden, wenn der Vorgang voraussichtlich einige Zeit in Anspruch nimmt (PendingIntent.getService), oder einen Broadcast-Empfänger (PendingIntent.getBroadcast).

Verwenden Sie diesen Code, um ein Problem an das Safety Center zu senden:

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 löst die Aktion auf:

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

Die gleiche Instanz von BroadcastReceiver im obigen Beispiel wird in AndroidManifest.xml deklariert:

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

Auf Ablehnungen von Problemen reagieren

Sie können eine PendingIntent-Instanz angeben, die ausgelöst werden kann, wenn eine SafetySourceIssue-Instanz geschlossen wird. Im Safety Center werden folgende Meldungen zu Problemen bearbeitet:

• Wenn eine Quelle ein Problem meldet, kann der Nutzer es auf dem Bildschirm des Sicherheitscenters schließen, indem er auf die Schaltfläche zum Schließen tippt (eine Schaltfläche mit einem X auf der Warnkarte).
• Wenn ein Nutzer ein Problem schließt und es weiterhin auftritt, wird es nicht noch einmal in der Benutzeroberfläche angezeigt.
• Dauerhafte Ablehnungen auf einem Laufwerk bleiben beim Neustart des Geräts erhalten.
• Wenn die Quelle im Play Console-Sicherheitscenter ein Problem nicht mehr meldet und es später wieder meldet, wird das Problem wieder angezeigt. So können Situationen berücksichtigt werden, in denen ein Nutzer eine Warnung sieht, sie schließt und dann eine Aktion ausführt, die das Problem beheben sollte. Der Nutzer führt dann aber wieder eine Aktion aus, die ein ähnliches Problem verursacht. Jetzt sollte die Warnkarte wieder angezeigt werden.
• Gelbe und rote Warnkarten werden alle 180 Tage wieder angezeigt, es sei denn, der Nutzer hat sie mehrmals geschlossen.

Zusätzliche Verhaltensweisen sollten von der Quelle nicht benötigt werden, es sei denn:

• Die Quelle versucht, dieses Verhalten anders zu implementieren, z. B. das Problem nie wieder auftreten zu lassen.
• Die Quelle versucht, dies als Rückruf zu verwenden, um beispielsweise die Informationen zu protokollieren.

Daten für mehrere Nutzer/Profile bereitstellen

Die SafetyCenterManager API kann für alle Nutzer und Profile verwendet werden. Weitere Informationen finden Sie unter Apps für mehrere Nutzer erstellen. Das Context-Objekt, das SafetyCenterManager bereitstellt, ist mit einer UserHandle-Instanz verknüpft. Die zurückgegebene SafetyCenterManager-Instanz interagiert daher mit dem Safety Center für diese UserHandle-Instanz. Standardmäßig ist Context mit dem ausführenden Nutzer verknüpft. Es ist jedoch möglich, eine Instanz für einen anderen Nutzer zu erstellen, wenn die App die Berechtigungen INTERACT_ACROSS_USERS und INTERACT_ACROSS_USERS_FULL hat. In diesem Beispiel wird ein Aufruf für mehrere Nutzer/Profile durchgeführt:

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

Jeder Nutzer auf dem Gerät kann mehrere verwaltete Profile haben. Das Sicherheitscenter bietet unterschiedliche Daten für jeden Nutzer, aber die Daten aller verwalteten Profile, die mit einem bestimmten Nutzer verknüpft sind, werden zusammengeführt.

Wenn profile="all_profiles" in der Konfigurationsdatei für die Quelle festgelegt ist, geschieht Folgendes:

• Es gibt einen UI-Eintrag für den Nutzer (übergeordnetes Profil) und alle zugehörigen verwalteten Profile (die titleForWork-Instanzen verwenden).

• Das Signal zum Aktualisieren oder Neuscannen wird an das übergeordnete Profil und alle zugehörigen verwalteten Profile gesendet. Der zugehörige Empfänger wird für jedes Profil gestartet und kann die zugehörigen Daten direkt an SafetyCenterManager senden, ohne dass ein profilübergreifender Aufruf erforderlich ist, es sei denn, der Empfänger oder die App ist singleUser.

• Die Quelle muss Daten für den Nutzer und alle seine verwalteten Profile bereitstellen. Die Daten für jeden UI-Eintrag können je nach Profil unterschiedlich sein.

Testen

Sie können auf ShadowSafetyCenterManager zugreifen und es in einem Robolectric-Test verwenden.

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

Sie können weitere End-to-End-Tests (E2E) schreiben, aber das liegt außerhalb des Geltungsbereichs dieses Leitfadens. Weitere Informationen zum Erstellen dieser E2E-Tests finden Sie unter CTS-Tests (CtsSafetyCenterTestCases).

Test- und interne APIs

Die internen APIs und Test-APIs sind nur für die interne Nutzung bestimmt und werden daher in diesem Leitfaden nicht ausführlich beschrieben. Wir werden jedoch einige interne APIs in Zukunft möglicherweise erweitern, damit OEMs ihre eigene Benutzeroberfläche erstellen können. Wir aktualisieren dann diesen Leitfaden, um Ihnen die Verwendung zu erläutern.

Berechtigungen

• MANAGE_SAFETY_CENTER
  • internal|installer|role
  • Wird für die internen Safety Center APIs verwendet
  • Nur für PermissionController und Shell gewährt

App "Einstellungen"

Weiterleitung zum Sicherheitscenter

Standardmäßig wird das Sicherheitscenter über die Einstellungen mit dem neuen Eintrag Sicherheit und Datenschutz aufgerufen. Wenn Sie eine andere Einstellungen App verwenden oder die Einstellungen App angepasst haben, müssen Sie möglicherweise anpassen, wie auf das Sicherheitscenter zugegriffen wird.

Wenn das Sicherheitscenter aktiviert ist:

• Der alte Eintrag Datenschutz ist ausgeblendet Code
• Der Eintrag Sicherheit im Legacy-Code ist ausgeblendet
• Neuer Eintrag Sicherheit und Datenschutz wird hinzugefügt code
• Der neue Eintrag Sicherheit und Datenschutz leitet zum Sicherheitscode des Sicherheitscenters weiter
• Bei Intent-Aktionen für android.settings.PRIVACY_SETTINGS und android.settings.SECURITY_SETTINGS wird das Sicherheitscenter geöffnet (Code: security, privacy)

Seiten mit erweiterten Sicherheits- und Datenschutzfunktionen

Die Einstellungen enthalten unter den Überschriften Weitere Sicherheitseinstellungen und Weitere Datenschutzeinstellungen weitere Einstellungen, die im Sicherheitscenter verfügbar sind:

• Erweiterter Sicherheitscode

  • security_advanced_settings.xml

  • SecurityAdvancedSettings.java

• Code für erweiterten Datenschutz

  • privacy_advanced_settings.xml

  • PrivacyDashboardFragment.java

• Ab Android 14 werden die Seiten mit erweiterten Sicherheits- und erweiterten Datenschutzeinstellungen auf einer einzigen Seite „Mehr Sicherheit und Datenschutz“ mit Intent-Aktion zusammengeführt. "com.android.settings.MORE_SECURITY_PRIVACY_SETTINGS"

Sicherheitsquellen

Das Sicherheitscenter ist in bestimmte Sicherheitsquellen eingebunden, die von der Einstellungen App bereitgestellt werden:

• Eine Sicherheitsquelle für den Sperrbildschirm prüft, ob ein Sperrbildschirm mit einem Sicherheitscode oder einer anderen Sicherheitsmaßnahme eingerichtet ist, um die privaten Daten des Nutzers vor externem Zugriff zu schützen.
• Eine biometrische Sicherheitsquelle (standardmäßig ausgeblendet) wird angezeigt, um sie in einen Fingerabdruck- oder Gesichtssensor einzubinden.

Der Quellcode für diese Safety Center-Quellen ist über die Android-Codesuche zugänglich. Wenn die Einstellungen-App nicht geändert wird (d. h., es werden keine Änderungen am Paketnamen, am Quellcode oder am Quellcode für den Sperrbildschirm und die biometrischen Funktionen vorgenommen), sollte diese Integration sofort funktionieren. Andernfalls sind möglicherweise einige Änderungen erforderlich, z. B. die Änderung der Konfigurationsdatei, um den Paketnamen der Einstellungen App und die Quellen zu ändern, die in das Sicherheitscenter eingebunden sind, sowie die Integration. Weitere Informationen finden Sie unter Konfigurationsdatei aktualisieren und Integrationseinstellungen.

PendingIntent

Wenn Sie die vorhandene Integration des Google Unternehmensprofils in der Einstellungen App unter Android 14 oder höher nutzen, wurde der unten beschriebene Fehler behoben. In diesem Fall ist das Lesen dieses Abschnitts nicht erforderlich.

Wenn Sie sicher sind, dass der Fehler nicht mehr auftritt, setzen Sie in den Einstellungen einen booleschen XML-Ressourcenkonfigurationswert von config_isSafetyCenterLockScreenPendingIntentFixed auf true, um die Umgehung im Sicherheitscenter zu deaktivieren.

Problemumgehung für PendingIntent

Dieser Fehler wird dadurch verursacht, dass die Einstellungen Intent-Instanz-Extras verwenden, um zu bestimmen, welches Fragment geöffnet werden soll. Da Intent#equals die zusätzlichen Elemente der Intent-Instanz nicht berücksichtigt, werden die PendingIntent-Instanz für das Zahnradsymbol und der Eintrag als gleich betrachtet und führen zur selben Benutzeroberfläche, obwohl sie eigentlich zu einer anderen Benutzeroberfläche führen sollen. Dieses Problem wurde in einem QPR-Release behoben, indem die PendingIntent-Instanzen nach Anfragecode unterschieden wurden. Alternativ kann dies mit Intent#setId unterschieden werden.

Interne Sicherheitsquellen

Einige Sicherheitscenter-Quellen sind intern und werden in der System-App „PermissionController“ im Modul „PermissionController“ implementiert. Diese Quellen verhalten sich wie normale Safety Center-Quellen und werden nicht gesondert behandelt. Der Code für diese Quellen ist über die Android-Codesuche verfügbar.

Dabei handelt es sich hauptsächlich um Datenschutzsignale, z. B.:

• Bedienungshilfen
• Berechtigungen für nicht verwendete Apps automatisch widerrufen
• Standortzugriff
• Benachrichtigungs-Listener
• Informationen zu den Arbeitsrichtlinien