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 d'exécuter Commands sur l'appareil.

La page Intégrer avec le SDK AMAPI fournit plus d'informations sur cette bibliothèque et sur la manière de l'ajouter à votre application.

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

É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 détails 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 comment émettre une requête de données d'application claire pour les packages spécifiés et attendre que la commande ait été exécutée avec succès. S'il est émis correctement, un objet Command sera renvoyé avec l'état actuel de la commande et l'ID de commande. Vous pourrez ensuite l'utiliser pour interroger l'état de n'importe quelle commande de longue durée.

Obtenir la commande

Une application d'extension peut interroger l'état des requêtes de commande précédemment émises. Pour récupérer l'état d'une commande, vous avez besoin de l'ID de commande (disponible dans la requête de commande d'émission). L'extrait de code suivant montre comment envoyer un GetCommandRequest à 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:

  1. Les changements d'état des commandes sont notifiés à CommandListener. Implémentez cette interface dans votre application et indiquez comment gérer les mises à jour d'état reçues.
  2. Étendez NotificationReceiverService et fournissez l'instance CommandListener.

  3. Spécifiez le nom de classe de l'NotificationReceiverService étendue dans la règle de l'API Android Management (voir la section "Configuration des règles").

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

  4. 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 fournir 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"
   }
 }]

Test

Tests unitaires

LocalCommandClient est une interface qui permet de fournir une implémentation testable.

Tests d'intégration

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

  1. Nom de package de l'extension d'application.
  2. Hachage SHA-256 à encodage hexadécimal de la signature associée au package de l'application.
  3. Éventuellement, si vous testez le rappel : nom complet du service issu du nouveau service pour prendre en charge le rappel. (Nom complet de CommandService dans l'exemple).