Apps de extensão e comandos locais

O SDK da API Android Management (AMAPI) permite que um app de extensão especificado pelo EMM se comunique diretamente com o Android Device Policy (ADP) e execute Commands no dispositivo.

A integração com o SDK da AMAPI fornece mais informações sobre essa biblioteca e como adicioná-la ao aplicativo.

Depois de integrado ao SDK, seu app de extensão pode se comunicar com o ADP para:

Comando de emissão

Um app de extensão pode solicitar que comandos sejam emitidos usando ADP. IssueCommandRequest contém o objeto de solicitação com detalhes sobre o comando a ser emitido e parâmetros específicos.

O snippet a seguir mostra como emitir uma solicitação para limpar os dados do pacote:

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

O exemplo anterior mostra a emissão de uma solicitação clara de dados do app para pacotes especificados e a espera até que o comando seja emitido com sucesso. Se emitido com sucesso, um objeto Command será retornado com o status atual do comando e o ID do comando, que pode ser usado posteriormente para consultar o status de qualquer comando de longa duração.

Receber comando

Um app de extensão pode consultar o status de solicitações de comando emitidas anteriormente. Para recuperar o status de um comando, você precisará do ID do comando, disponível na solicitação de comando "issue". O snippet abaixo mostra como enviar um GetCommandRequest para o 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());
  }
  ...

Detectar callbacks de alteração de status do comando

Um app de extensão pode registrar um callback para receber atualizações de mudanças de status de comandos de longa execução seguindo estas etapas:

  1. As mudanças de status do comando são notificadas para CommandListener. Implemente essa interface no app e fornecem implementação sobre como lidar com as atualizações de status recebidas.
  2. Estenda NotificationReceiverService e forneça a instância CommandListener.

  3. Especifique o nome da classe do NotificationReceiverService estendido na política da API Android Management. Consulte a configuração da política.

    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. Adicione o serviço ao AndroidManifest.xml e verifique se ele foi exportado.

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

Configuração da política

Para permitir que o app de extensão se comunique diretamente com o ADP, o EMM precisa fornecer uma política 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"
   }
 }]

testes

Teste de unidade

LocalCommandClient é uma interface e, portanto, permite fornecer uma implementação testável.

Teste de integração

As seguintes informações são necessárias para testar com o ADP:

  1. Nome do pacote do app da extensão.
  2. O hash SHA-256 da assinatura codificado em hexadecimal da assinatura associada ao pacote do app.
  3. Opcionalmente, se estiver testando o callback: nome totalmente qualificado do serviço do serviço recém-lançado para oferecer suporte ao callback. (Nome totalmente qualificado de CommandService no exemplo).