Mehrere Nutzer verwalten

In diesem Entwicklerhandbuch wird erläutert, wie Ihr Device Policy Controller (DPC) mehrere Android-Nutzer auf zweckbestimmten Geräten verwalten kann.

Übersicht

Ihr DPC kann mehrere Personen dabei unterstützen, ein zweckbestimmtes Gerät gemeinsam zu verwenden. Ihr DPC, der auf einem vollständig verwalteten Gerät ausgeführt wird, kann zwei Arten von Nutzern erstellen und verwalten:

• Sekundäre Nutzer sind Android-Nutzer, bei denen zwischen den Sitzungen separate Apps und Daten gespeichert werden. Sie verwalten den Nutzer mit einer Administratorkomponente. Diese Nutzer sind nützlich, wenn ein Gerät zu Beginn einer Schicht abgeholt wird, z. B. Lieferfahrer oder Sicherheitsmitarbeiter.
• Sitzungsspezifische Nutzer sind sekundäre Nutzer, die vom System gelöscht werden, wenn der Nutzer die Verbindung beendet, das Gerät verlässt oder das Gerät neu startet. Diese Nutzer sind nützlich, wenn Daten nach Ende der Sitzung gelöscht werden können, z. B. bei Internetkiosks mit öffentlichem Zugriff.

Sie verwenden Ihren vorhandenen DPC, um das dedizierte Gerät und die sekundären Nutzer zu verwalten. Eine Administratorkomponente in Ihrem DPC legt sich selbst als Administrator für neue sekundäre Nutzer fest, wenn diese erstellt werden.

Administratoren eines sekundären Nutzers müssen zum selben Paket gehören wie der Administrator des vollständig verwalteten Geräts. Zur Vereinfachung der Entwicklung empfehlen wir, einen Administrator zwischen dem Gerät und sekundären Nutzern zu teilen.

Für die Verwaltung mehrerer Nutzer auf zweckbestimmten Geräten ist normalerweise Android 9.0 erforderlich. Einige der in diesem Entwicklerhandbuch verwendeten Methoden sind jedoch auch in früheren Android-Versionen verfügbar.

Nutzer erstellen

Ihr DPC kann im Hintergrund zusätzliche Nutzer erstellen und sie dann in den Vordergrund versetzen. Der Prozess ist für sekundäre und sitzungsspezifische Nutzer nahezu identisch. Implementieren Sie die folgenden Schritte für die Administratoren des vollständig verwalteten Geräts und des sekundären Nutzers:

1. Rufen Sie DevicePolicyManager.createAndManageUser() auf. Wenn Sie einen sitzungsspezifischen Nutzer erstellen möchten, fügen Sie MAKE_USER_EPHEMERAL in das Argument „Flags“ ein.
2. Rufen Sie DevicePolicyManager.startUserInBackground() auf, um den Nutzer im Hintergrund zu starten. Der Nutzer beginnt mit der Ausführung, aber Sie sollten die Einrichtung abschließen, bevor Sie den Nutzer in den Vordergrund bringen und dies der Person zeigen, die das Gerät verwendet.
3. Rufen Sie im Administrator des sekundären Nutzers DevicePolicyManager.setAffiliationIds() auf, um den neuen Nutzer mit dem primären Nutzer zu verknüpfen. Weitere Informationen finden Sie unten im Abschnitt DPC-Koordination.
4. Rufen Sie zurück zum Administrator des vollständig verwalteten Geräts DevicePolicyManager.switchUser() auf, um den Nutzer in den Vordergrund zu versetzen.

Das folgende Beispiel zeigt, wie Sie Schritt 1 Ihrem DPC hinzufügen können:

val dpm = getContext().getSystemService(Context.DEVICE_POLICY_SERVICE)
        as DevicePolicyManager

// If possible, reuse an existing affiliation ID across the
// primary user and (later) the ephemeral user.
val identifiers = dpm.getAffiliationIds(adminName)
if (identifiers.isEmpty()) {
    identifiers.add(UUID.randomUUID().toString())
    dpm.setAffiliationIds(adminName, identifiers)
}

// Pass an affiliation ID to the ephemeral user in the admin extras.
val adminExtras = PersistableBundle()
adminExtras.putString(AFFILIATION_ID_KEY, identifiers.first())
// Include any other config for the new user here ...

// Create the ephemeral user, using this component as the admin.
try {
    val ephemeralUser = dpm.createAndManageUser(
            adminName,
            "tmp_user",
            adminName,
            adminExtras,
            DevicePolicyManager.MAKE_USER_EPHEMERAL or
                    DevicePolicyManager.SKIP_SETUP_WIZARD)

} catch (e: UserManager.UserOperationException) {
    if (e.userOperationResult ==
            UserManager.USER_OPERATION_ERROR_MAX_USERS) {
        // Find a way to free up users...
    }
}

DevicePolicyManager dpm = (DevicePolicyManager)
    getContext().getSystemService(Context.DEVICE_POLICY_SERVICE);

// If possible, reuse an existing affiliation ID across the
// primary user and (later) the ephemeral user.
Set<String> identifiers = dpm.getAffiliationIds(adminName);
if (identifiers.isEmpty()) {
  identifiers.add(UUID.randomUUID().toString());
  dpm.setAffiliationIds(adminName, identifiers);
}

// Pass an affiliation ID to the ephemeral user in the admin extras.
PersistableBundle adminExtras = new PersistableBundle();
adminExtras.putString(AFFILIATION_ID_KEY, identifiers.iterator().next());
// Include any other config for the new user here ...

// Create the ephemeral user, using this component as the admin.
try {
  UserHandle ephemeralUser = dpm.createAndManageUser(
      adminName,
      "tmp_user",
      adminName,
      adminExtras,
      DevicePolicyManager.MAKE_USER_EPHEMERAL |
          DevicePolicyManager.SKIP_SETUP_WIZARD);

} catch (UserManager.UserOperationException e) {
  if (e.getUserOperationResult() ==
      UserManager.USER_OPERATION_ERROR_MAX_USERS) {
    // Find a way to free up users...
  }
}

Wenn Sie einen neuen Nutzer erstellen oder starten, können Sie den Grund für Fehler prüfen, indem Sie die Ausnahme UserOperationException erfassen und getUserOperationResult() aufrufen. Das Überschreiten der Nutzerlimits führt häufig zu Fehlern:

• USER_OPERATION_ERROR_MAX_USERS
• USER_OPERATION_ERROR_MAX_RUNNING_USERS

Das Erstellen eines Nutzers kann einige Zeit dauern. Wenn Sie häufig Nutzer erstellen, können Sie die Nutzererfahrung verbessern, indem Sie einen einsatzbereiten Nutzer im Hintergrund vorbereiten. Möglicherweise müssen Sie die Vorteile eines sofort einsatzbereiten Nutzers gegen die maximal zulässige Anzahl von Nutzern auf einem Gerät abwägen.

Identifizierung

Nachdem Sie einen neuen Nutzer erstellt haben, sollten Sie den Nutzer mit einer festen Seriennummer verweisen. Behalten Sie die UserHandle nicht bei, da sie beim Erstellen und Löschen von Nutzern vom System wiederverwendet werden. Rufen Sie UserManager.getSerialNumberForUser() auf, um die Seriennummer abzurufen:

// After calling createAndManageUser() use a device-unique serial number
// (that isn’t recycled) to identify the new user.
secondaryUser?.let {
    val userManager = getContext().getSystemService(UserManager::class.java)
    val ephemeralUserId = userManager!!.getSerialNumberForUser(it)
    // Save the serial number to storage  ...
}

// After calling createAndManageUser() use a device-unique serial number
// (that isn’t recycled) to identify the new user.
if (secondaryUser != null) {
  UserManager userManager = getContext().getSystemService(UserManager.class);
  long ephemeralUserId = userManager.getSerialNumberForUser(secondaryUser);
  // Save the serial number to storage  ...
}

Nutzerkonfiguration

Je nach den Anforderungen Ihrer Nutzer können Sie die Einrichtung sekundärer Nutzer anpassen. Beim Aufrufen von createAndManageUser() können Sie die folgenden Flags angeben:

SKIP_SETUP_WIZARD

Überspringt die Ausführung des Assistenten für die Einrichtung für neue Nutzer, der nach Updates sucht und installiert, fordert den Nutzer auf, zusammen mit Google-Diensten ein Google-Konto hinzuzufügen, und eine Displaysperre wird eingerichtet. Das kann einige Zeit in Anspruch nehmen und gilt möglicherweise nicht für alle Nutzer, z. B. öffentliche Internetkioske.

LEAVE_ALL_SYSTEM_APPS_ENABLED

Alle System-Apps des neuen Nutzers bleiben aktiviert. Wenn Sie dieses Flag nicht festlegen, enthält der neue Nutzer nur die minimalen Apps, die das Telefon für den Betrieb des Telefons benötigt. Normalerweise sind das ein Dateibrowser, ein Telefon-Telefon, Kontakte und SMS-Nachrichten.

Nutzerlebenszyklus verfolgen

Ihr DPC (wenn er ein Administrator des vollständig verwalteten Geräts ist) kann hilfreich sein zu wissen, wenn sekundäre Nutzer wechseln. Um nach Änderungen Folgeaufgaben auszuführen, überschreiben Sie diese Callback-Methoden in der Unterklasse DeviceAdminReceiver Ihres DPC:

onUserStarted()

Wird aufgerufen, nachdem der Nutzer durch das System gestartet wurde. Dieser Nutzer wird möglicherweise noch eingerichtet oder im Hintergrund ausgeführt. Sie können den Nutzer über das Argument startedUser abrufen.

onUserSwitched()

Wird aufgerufen, nachdem das System zu einem anderen Nutzer gewechselt hat. Sie können den neuen Nutzer, der jetzt im Vordergrund ausgeführt wird, über das Argument switchedUser abrufen.

onUserStopped()

Wird aufgerufen, nachdem das System einen Nutzer gestoppt hat, weil er sich abgemeldet hat, zu einem neuen Nutzer gewechselt ist (wenn der Nutzer sitzungsspezifisch ist) oder der Nutzer vom DPC gestoppt wurde. Sie können den Nutzer über das Argument stoppedUser abrufen.

onUserAdded()

Wird aufgerufen, wenn das System einen neuen Nutzer hinzufügt. Normalerweise sind sekundäre Nutzer nicht vollständig eingerichtet, wenn Ihr DPC den Callback empfängt. Sie können den Nutzer über das Argument newUser abrufen.

onUserRemoved()

Wird aufgerufen, nachdem ein Nutzer vom System gelöscht wurde. Da der Nutzer bereits gelöscht wurde, können Sie nicht auf den Nutzer zugreifen, der durch das Argument removedUser dargestellt wird.

Apps können einen Empfänger für die Broadcasts ACTION_USER_FOREGROUND und ACTION_USER_BACKGROUND registrieren, um zu erkennen, wann das System einen Nutzer in den Vordergrund oder in den Hintergrund leitet.

Nutzer finden

Um alle sekundären Nutzer abzurufen, kann ein Administrator eines vollständig verwalteten Geräts DevicePolicyManager.getSecondaryUsers() aufrufen. Die Ergebnisse umfassen alle sekundären oder sitzungsspezifischen Nutzer, die der Administrator erstellt hat. Die Ergebnisse umfassen auch alle sekundären Nutzer (oder Gastnutzer), die eine Person, die das Gerät verwendet, erstellt hat. Die Ergebnisse enthalten keine Arbeitsprofile, da es sich nicht um sekundäre Nutzer handelt. Das folgende Beispiel zeigt, wie Sie diese Methode verwenden können:

// The device is stored for the night. Stop all running secondary users.
dpm.getSecondaryUsers(adminName).forEach {
    dpm.stopUser(adminName, it)
}

// The device is stored for the night. Stop all running secondary users.
for (UserHandle user : dpm.getSecondaryUsers(adminName)) {
  dpm.stopUser(adminName, user);
}

Hier sind weitere Methoden, die Sie aufrufen können, um den Status sekundärer Nutzer zu ermitteln:

DevicePolicyManager.isEphemeralUser()

Rufen Sie diese Methode vom Administrator eines sekundären Nutzers auf, um herauszufinden, ob es sich um einen sitzungsspezifischen Nutzer handelt.

DevicePolicyManager.isAffiliatedUser()

Rufen Sie diese Methode vom Administrator eines sekundären Nutzers auf, um herauszufinden, ob dieser Nutzer mit dem primären Nutzer verbunden ist. Weitere Informationen zur Verknüpfung finden Sie unten im Abschnitt DPC-Koordination.

Nutzerverwaltung

Wenn Sie den Nutzerlebenszyklus vollständig verwalten möchten, können Sie APIs aufrufen, um genau zu steuern, wann und wie das Gerät Nutzer ändert. Sie können beispielsweise einen Nutzer löschen, wenn ein Gerät über einen bestimmten Zeitraum nicht verwendet wurde, oder nicht gesendete Bestellungen an einen Server senden, bevor die Schicht beendet ist.

Abmelden

Unter Android 9.0 wurde dem Sperrbildschirm eine Schaltfläche zum Abmelden hinzugefügt, damit eine Person, die das Gerät verwendet, ihre Sitzung beenden kann. Nach dem Tippen auf die Schaltfläche stoppt das System den sekundären Nutzer und löscht den Nutzer, falls er sitzungsspezifisch ist, und der Hauptnutzer kehrt in den Vordergrund zurück. Wenn sich der Hauptnutzer im Vordergrund befindet, wird die Schaltfläche von Android ausgeblendet, da der Hauptnutzer sich nicht abmelden kann.

In Android wird die Schaltfläche zum Beenden der Sitzung nicht standardmäßig angezeigt, aber Ihr Administrator (eines vollständig verwalteten Geräts) kann sie durch Aufrufen von DevicePolicyManager.setLogoutEnabled() aktivieren. Wenn du den aktuellen Status der Schaltfläche bestätigen möchtest, rufe DevicePolicyManager.isLogoutEnabled() auf.

Der Administrator eines sekundären Nutzers kann den Nutzer programmatisch abmelden und zum primären Nutzer zurückkehren. Prüfen Sie zuerst, ob der sekundäre und der primäre Nutzer verbunden sind, und rufen Sie dann DevicePolicyManager.logoutUser() auf. Wenn der abgemeldete Nutzer ein sitzungsspezifischer Nutzer ist, wird das System beendet und dann gelöscht.

Nutzer wechseln

Um zu einem anderen sekundären Nutzer zu wechseln, kann der Administrator eines vollständig verwalteten Geräts DevicePolicyManager.switchUser() aufrufen. Der Einfachheit halber können Sie null übergeben, um zum Hauptnutzer zu wechseln.

Nutzer anhalten

Um einen sekundären Nutzer zu beenden, kann ein DPC, der ein vollständig verwaltetes Gerät besitzt, DevicePolicyManager.stopUser() aufrufen. Wenn der beendete Nutzer ein sitzungsspezifischer Nutzer ist, wird er gestoppt und dann gelöscht.

Wir empfehlen, Nutzer nach Möglichkeit zu beenden, damit die maximale Anzahl an aktiven Nutzern für das Gerät nicht überschritten wird.

Nutzer löschen

Um einen sekundären Nutzer endgültig zu löschen, kann ein DPC eine der folgenden DevicePolicyManager-Methoden aufrufen:

• Ein Administrator eines vollständig verwalteten Geräts kann removeUser() anrufen.
• Ein Administrator des sekundären Nutzers kann wipeData() aufrufen.

Sitzungsspezifische Nutzer werden vom System gelöscht, wenn sie abgemeldet, gestoppt oder weggewechselt wurden.

Standard-UI deaktivieren

Wenn Ihr DPC eine UI für die Nutzerverwaltung bereitstellt, können Sie die integrierte Android-Oberfläche mit mehreren Benutzern deaktivieren. Rufen Sie dazu DevicePolicyManager.setLogoutEnabled() auf und fügen Sie die Einschränkung DISALLOW_USER_SWITCH hinzu, wie im folgenden Beispiel gezeigt:

// Explicitly disallow logging out using Android UI (disabled by default).
dpm.setLogoutEnabled(adminName, false)

// Disallow switching users in Android's UI. This DPC can still
// call switchUser() to manage users.
dpm.addUserRestriction(adminName, UserManager.DISALLOW_USER_SWITCH)

// Explicitly disallow logging out using Android UI (disabled by default).
dpm.setLogoutEnabled(adminName, false);

// Disallow switching users in Android's UI. This DPC can still
// call switchUser() to manage users.
dpm.addUserRestriction(adminName, UserManager.DISALLOW_USER_SWITCH);

Die Person, die das Gerät verwendet, kann über die integrierte Android-UI keine sekundären Nutzer hinzufügen, da Administratoren von vollständig verwalteten Geräten automatisch die Nutzereinschränkung DISALLOW_ADD_USER hinzufügen.

Sitzungsnachrichten

Wenn die Person, die ein Gerät verwendet, zu einem neuen Nutzer wechselt, zeigt Android ein Steuerfeld, in dem der Schalter hervorgehoben wird. Android zeigt die folgenden Meldungen an:

• Mitteilung zur Nutzersitzung: Diese wird angezeigt, wenn das Gerät vom primären Nutzer zu einem sekundären Nutzer wechselt.
• Nachricht der Endnutzersitzung, die angezeigt wird, wenn das Gerät von einem sekundären Nutzer zum primären Nutzer zurückkehrt.

Im System werden die Nachrichten nicht angezeigt, wenn zwischen zwei sekundären Nutzern gewechselt wird.

Da die Nachrichten möglicherweise nicht für alle Situationen geeignet sind, können Sie den Text dieser Nachrichten ändern. Wenn Ihre Lösung beispielsweise sitzungsspezifische Nutzersitzungen verwendet, können Sie dies in folgenden Meldungen berücksichtigen: Browsersitzung wird beendet und personenbezogene Daten gelöscht...

Das System zeigt die Nachricht nur einige Sekunden lang an, sodass jede Nachricht eine kurze, klare Wortgruppe sein sollte. Zum Anpassen der Nachrichten kann Ihr Administrator die DevicePolicyManager-Methoden setStartUserSessionMessage() und setEndUserSessionMessage() aufrufen, wie im folgenden Beispiel gezeigt:

// Short, easy-to-read messages shown at the start and end of a session.
// In your app, store these strings in a localizable resource.
internal val START_USER_SESSION_MESSAGE = "Starting guest session…"
internal val END_USER_SESSION_MESSAGE = "Stopping & clearing data…"

// ...
dpm.setStartUserSessionMessage(adminName, START_USER_SESSION_MESSAGE)
dpm.setEndUserSessionMessage(adminName, END_USER_SESSION_MESSAGE)

// Short, easy-to-read messages shown at the start and end of a session.
// In your app, store these strings in a localizable resource.
private static final String START_USER_SESSION_MESSAGE = "Starting guest session…";
private static final String END_USER_SESSION_MESSAGE = "Stopping & clearing data…";

// ...
dpm.setStartUserSessionMessage(adminName, START_USER_SESSION_MESSAGE);
dpm.setEndUserSessionMessage(adminName, END_USER_SESSION_MESSAGE);

Übergeben Sie null, um Ihre benutzerdefinierten Nachrichten zu löschen und zu den Standardnachrichten von Android zurückzukehren. Wenn Sie den aktuellen Nachrichtentext prüfen möchten, rufen Sie getStartUserSessionMessage() oder getEndUserSessionMessage() auf.

Dein DPC sollte lokalisierte Nachrichten für die aktuelle Sprache des Nutzers festlegen. Sie müssen die Meldungen auch aktualisieren, wenn sich die Sprache des Nutzers ändert:

override fun onReceive(context: Context?, intent: Intent?) {
    // Added the <action android:name="android.intent.action.LOCALE_CHANGED" />
    // intent filter for our DeviceAdminReceiver subclass in the app manifest file.
    if (intent?.action === ACTION_LOCALE_CHANGED) {

        // Android's resources return a string suitable for the new locale.
        getManager(context).setStartUserSessionMessage(
                getWho(context),
                context?.getString(R.string.start_user_session_message))

        getManager(context).setEndUserSessionMessage(
                getWho(context),
                context?.getString(R.string.end_user_session_message))
    }
    super.onReceive(context, intent)
}

public void onReceive(Context context, Intent intent) {
  // Added the <action android:name="android.intent.action.LOCALE_CHANGED" />
  // intent filter for our DeviceAdminReceiver subclass in the app manifest file.
  if (intent.getAction().equals(ACTION_LOCALE_CHANGED)) {

    // Android's resources return a string suitable for the new locale.
    getManager(context).setStartUserSessionMessage(
        getWho(context),
        context.getString(R.string.start_user_session_message));

    getManager(context).setEndUserSessionMessage(
        getWho(context),
        context.getString(R.string.end_user_session_message));
  }
  super.onReceive(context, intent);
}

DPC-Koordination

Für die Verwaltung sekundärer Nutzer sind in der Regel zwei Instanzen Ihres DPCs erforderlich – eine, die das vollständig verwaltete Gerät besitzt, und die andere, die den sekundären Nutzer besitzt. Beim Erstellen eines neuen Nutzers legt der Administrator des vollständig verwalteten Geräts eine andere Instanz von sich selbst als Administrator des neuen Nutzers fest.

Zugehörige Nutzer

Einige der APIs in diesem Entwicklerhandbuch funktionieren nur, wenn die sekundären Nutzer verbunden sind. Da Android einige Funktionen (z. B. Netzwerk-Logging) deaktiviert, wenn Sie dem Gerät neue nicht verbundene sekundäre Nutzer hinzufügen, sollten Sie Nutzer so schnell wie möglich verknüpfen. Sehen Sie sich dazu das Beispiel unter Einrichtung unten an.

Einrichten

Richten Sie neue sekundäre Nutzer (über den DPC, dem der sekundäre Nutzer gehört) ein, bevor Sie anderen Nutzern die Verwendung erlauben. Sie können diese Einrichtung über den DeviceAdminReceiver.onEnabled()-Callback vornehmen. Wenn Sie zuvor Administrator-Extras im Aufruf von createAndManageUser() festgelegt haben, können Sie die Werte über das Argument intent abrufen. Das folgende Beispiel zeigt einen DPC, der einen neuen sekundären Nutzer im Callback zuordnet:

override fun onEnabled(context: Context?, intent: Intent?) {
    super.onEnabled(context, intent)

    // Get the affiliation ID (our DPC previously put in the extras) and
    // set the ID for this new secondary user.
    intent?.getStringExtra(AFFILIATION_ID_KEY)?.let {
        val dpm = getManager(context)
        dpm.setAffiliationIds(getWho(context), setOf(it))
    }
    // Continue setup of the new secondary user ...
}

public void onEnabled(Context context, Intent intent) {
  // Get the affiliation ID (our DPC previously put in the extras) and
  // set the ID for this new secondary user.
  String affiliationId = intent.getStringExtra(AFFILIATION_ID_KEY);
  if (affiliationId != null) {
    DevicePolicyManager dpm = getManager(context);
    dpm.setAffiliationIds(getWho(context),
        new HashSet<String>(Arrays.asList(affiliationId)));
  }
  // Continue setup of the new secondary user ...
}

RPCs zwischen DPCs

Auch wenn die beiden DPC-Instanzen unter verschiedenen Nutzern ausgeführt werden, können die DPCs, denen das Gerät gehört, und die sekundären Nutzer miteinander kommunizieren. Da der Aufruf eines anderen DPC-Dienstes Nutzergrenzen überschreitet, kann Ihr DPC nicht bindService() wie normalerweise in Android aufrufen. Rufen Sie zur Bindung an einen Dienst, der von einem anderen Nutzer ausgeführt wird, DevicePolicyManager.bindDeviceAdminServiceAsUser() auf.

Ihr DPC kann nur an Dienste gebunden werden, die in den von DevicePolicyManager.getBindDeviceAdminTargetUsers() zurückgegebenen Nutzern ausgeführt werden. Das folgende Beispiel zeigt den Administrator einer sekundären Nutzerbindung an den Administrator des vollständig verwalteten Geräts:

// From a secondary user, the list contains just the primary user.
dpm.getBindDeviceAdminTargetUsers(adminName).forEach {

    // Set up the callbacks for the service connection.
    val intent = Intent(mContext, FullyManagedDeviceService::class.java)
    val serviceconnection = object : ServiceConnection {
        override fun onServiceConnected(componentName: ComponentName,
                                        iBinder: IBinder) {
            // Call methods on service ...
        }
        override fun onServiceDisconnected(componentName: ComponentName) {
            // Clean up or reconnect if needed ...
        }
    }

    // Bind to the service as the primary user [it].
    val bindSuccessful = dpm.bindDeviceAdminServiceAsUser(adminName,
            intent,
            serviceconnection,
            Context.BIND_AUTO_CREATE,
            it)
}

// From a secondary user, the list contains just the primary user.
List<UserHandle> targetUsers = dpm.getBindDeviceAdminTargetUsers(adminName);
if (targetUsers.isEmpty()) {
  // If the users aren't affiliated, the list doesn't contain any users.
  return;
}

// Set up the callbacks for the service connection.
Intent intent = new Intent(mContext, FullyManagedDeviceService.class);
ServiceConnection serviceconnection = new ServiceConnection() {
  @Override
  public void onServiceConnected(
      ComponentName componentName, IBinder iBinder) {
    // Call methods on service ...
  }

  @Override
  public void onServiceDisconnected(ComponentName componentName) {
    // Clean up or reconnect if needed ...
  }
};

// Bind to the service as the primary user.
UserHandle primaryUser = targetUsers.get(0);
boolean bindSuccessful = dpm.bindDeviceAdminServiceAsUser(
    adminName,
    intent,
    serviceconnection,
    Context.BIND_AUTO_CREATE,
    primaryUser);

Weitere Informationen

Weitere Informationen zu dedizierten Geräten finden Sie in den folgenden Dokumenten:

• Übersicht über dedizierte Geräte
• In Modus „Aufgaben sperren“ wird erläutert, wie Sie ein dediziertes Gerät für eine einzelne App oder eine Gruppe von Apps sperren.
• Cookbook für dedizierte Geräte mit weiteren Beispielen, um die entsprechenden Geräte einzuschränken und die Nutzererfahrung zu verbessern.