Cette page a été traduite par l'API Cloud Translation.

Applications d'extension et commandes locales

Le SDK de l'API Android Management (AMAPI) permet à une application d'extension spécifiée par un fournisseur EMM de communiquer directement avec Android Device Policy (ADP) et exécuter Commands sur l'appareil.

Embed with the AMAPI SDK (Intégrer avec le SDK AMAPI) fournit plus d'informations sur cette bibliothèque et comment l'ajouter à votre application.

Une fois le SDK intégré, votre application d'extension peut communiquer avec ADP pour:

envoyer des requêtes de commande
interroger l'état des requêtes de commande
recevoir les changements d'état des commandes

Émettre une commande

Une application d'extension peut demander l'émission de commandes à l'aide d'ADP. IssueCommandRequest contient l'objet de la requête qui contiendra des informations sur la commande à émettre et des paramètres spécifiques.

L'extrait de code suivant montre comment envoyer une demande de suppression des données du package:

import android.util.Log;
...
import com.google.android.managementapi.commands.LocalCommandClientFactory;
import com.google.android.managementapi.commands.model.Command;
import com.google.android.managementapi.commands.model.GetCommandRequest;
import com.google.android.managementapi.commands.model.IssueCommandRequest;
import com.google.android.managementapi.commands.model.IssueCommandRequest.ClearAppsData;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;

...
  void issueClearAppDataCommand(ImmutableList<String> packageNames) {
    Futures.addCallback(
        LocalCommandClientFactory.create(getContext())
            .issueCommand(createClearAppRequest(packageNames)),
        new FutureCallback<Command>() {
          @Override
          public void onSuccess(Command result) {
            // Process the returned command result here
            Log.i(TAG, "Successfully issued command");
          }

          @Override
          public void onFailure(Throwable t) {
            Log.e(TAG, "Failed to issue command", t);
          }
        },
        MoreExecutors.directExecutor());
  }

  IssueCommandRequest createClearAppRequest(ImmutableList<String> packageNames) {
    return IssueCommandRequest.builder()
        .setClearAppsData(
            ClearAppsData.builder()
                .setPackageNames(packageNames)
                .build()
        )
        .build();
  }
...

L'exemple précédent montre l'émission d'une requête de données d'application claire pour packages et en attendant que la commande ait été lancée avec succès. Si avec succès, un objet Command sera renvoyé avec la valeur l'état de la commande et l'ID de commande qui peut être utilisé ultérieurement pour interroger l'état de les commandes de longue durée.

Obtenir la commande

Une application d'extension peut interroger l'état des requêtes de commande précédemment émises. À récupérer l'état d'une commande, vous aurez besoin de l'ID de commande (disponible dans la émission de commande). L'extrait de code suivant montre comment envoyer un GetCommandRequest vers ADP.

import android.util.Log;
...
import com.google.android.managementapi.commands.LocalCommandClientFactory;
...
import com.google.android.managementapi.commands.model.GetCommandRequest;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;

...
  void getCommand(String commandId) {
    Futures.addCallback(
        LocalCommandClientFactory.create(getApplication())
            .getCommand(GetCommandRequest.builder().setCommandId(commandId).build()),
        new FutureCallback<Command>() {
          @Override
          public void onSuccess(Command result) {
            // Process the returned command result here
            Log.i(Constants.TAG, "Successfully issued command");
          }

          @Override
          public void onFailure(Throwable t) {
            Log.e(Constants.TAG, "Failed to issue command", t);
          }
        },
        MoreExecutors.directExecutor());
  }
  ...

Écouter les rappels de changement d'état de la commande

Une application d'extension peut enregistrer un rappel pour recevoir des informations sur les changements d'état des commandes de longue durée en procédant comme suit:

Les changements d'état des commandes sont notifiés à CommandListener. Implémentez ceci de votre application et fournir des informations sur la manière de gérer reçu des mises à jour de statut.
Étendre NotificationReceiverService et fournir CommandListener Compute Engine.

Spécifier le nom de classe de l'NotificationReceiverService étendue dans Android la stratégie de l'API Management (voir la configuration des stratégies).

import com.google.android.managementapi.commands.CommandListener;
import com.google.android.managementapi.notification.NotificationReceiverService;

...

public class SampleCommandService extends NotificationReceiverService {

  @Override
  protected void setupInjection() {
    // (Optional) If using DI and needs initialisation then use this method.
  }

  @Override
  public CommandListener getCommandListener() {
    // return the concrete implementation from previous step
    return ...;
  }
}

Ajoutez le service à votre fichier AndroidManifest.xml et assurez-vous qu'il est exporté.

<service
 android:name = ".notification.SampleCommandService"
 android:exported = "true" />

Configuration des règles

Pour permettre à l'application d'extension de communiquer directement avec ADP, l'EMM doit fournissez une règle extensionConfig.

 "applications": [{
   "packageName": "com.amapi.extensibility.demo",
   ...
   "extensionConfig": {
     "signingKeyFingerprintsSha256": [
       // Include signing key of extension app
     ],
     // Optional if callback is implemented
     "notificationReceiver": "com.amapi.extensibility.demo.notification.SampleCommandService"
   }
 }]

Tests

Tests unitaires

LocalCommandClient est une interface qui permet de fournir un testable la mise en œuvre.

Tests d'intégration

Vous aurez besoin des informations suivantes pour effectuer le test avec ADP:

Nom de package de l'extension d'application.
Hachage SHA-256 de la signature associée à l'application, encodé en hexadécimal d'un package.
Éventuellement, si vous testez le rappel, il s'agit du nom complet du service le nouveau service pour permettre le rappel. (Nom complet CommandService dans l'exemple).