Gestire le app personalizzate con AMAPI

In qualità di EMM basato sull'API Android Management, puoi gestire da remoto le applicazioni personalizzate sui dispositivi. Sono incluse sia l'installazione sia la disinstallazione di queste app. Questa funzionalità viene ottenuta sviluppando un'app di estensione localmente utilizzando l'SDK AMAPI.

Prerequisiti

  • L'app di estensione è integrata con l'SDK AMAPI.
  • Il dispositivo è completamente gestito.
  • È necessario l'SDK AMAPI v1.6.0-rc01 o versioni successive.

1. Preparare l'app per l'utilizzo della funzionalità

1.1. Eseguire l'integrazione con l'SDK AMAPI nell'app di estensione

La procedura di gestione delle app personalizzate richiede l'integrazione dell'SDK AMAPI nell'app di estensione. Puoi trovare ulteriori informazioni su questa libreria e su come aggiungerla alla tua app nella guida all'integrazione dell'SDK AMAPI.

1.2. Aggiorna il manifest dell'app per supportare FileProvider

  • Aggiungi all'elemento <queries> del tuo AndroidManifest.xml l'applicazione Android Device Policy (ADP) come mostrato nella guida all'integrazione dell'SDK AMAPI .
  • Implementa il seguente snippet <provider> nel AndroidManifest.xml della tua app all'interno del tag <application>. Questo snippet viene utilizzato per archiviare i file durante la condivisione dell'APK dell'app personalizzata, consentendo l'installazione di app personalizzate utilizzando AMAPI.

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.customapp">
  <queries>
    <package android:name="com.google.android.apps.work.clouddpc" />
  </queries>

  <application>

    <!--This is used to store files when sharing the custom app apk.-->
    <provider
        android:name="com.google.android.managementapi.customapp.provider.CustomAppProvider"
        android:authorities="${applicationId}.AmapiCustomAppProvider"
        android:exported="false"
        android:grantUriPermissions="true">
      <meta-data
          android:name="android.support.FILE_PROVIDER_PATHS"
          android:resource="@xml/file_provider_paths" />
    </provider>
  </application>
</manifest>
  • Crea un nuovo file XML nella directory res/xml/ della tua app contenente il percorso di archiviazione per gli APK personalizzati.

file_provider_paths.xml:

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
  <cache-path
      name="android_managementapi_custom_apks"
      path="com.google.android.managementapi/customapp/apks/" />
</paths>

2. Integrare la funzionalità di app personalizzata dell'SDK AMAPI

2.1. Prepara il file APK personalizzato per l'installazione

Prima del deployment, il file APK dell'applicazione deve essere preparato per l'installazione. Il seguente snippet di codice mostra la procedura:

Kotlin

import android.net.Uri
import androidx.core.net.Uri
import java.io.File
...
import com.google.android.managementapi.commands.LocalCommandClient
import com.google.android.managementapi.commands.LocalCommandClient.InstallCustomAppCommandHelper
import com.google.android.managementapi.commands.LocalCommandClientFactory

...

fun prepareApkFile(): Uri? {
    // Get the storage location of custom APK files from AM API
    val client: LocalCommandClient = LocalCommandClientFactory.create(context)
    val installCustomAppCommandHelper = client.installCustomAppCommandHelper

    val customApksStorageDir: File = installCustomAppCommandHelper.customApksStorageDirectory ?: return null

    // Once you get hold of the custom APKs storage directory, you must store your custom APK
    // in that location before issuing the install command.
    val customApkFile: File = fetchMyAppToDir(customApksStorageDir) ?: return null
    val customApkFileUri: Uri = customApkFile.toUri()

    return customApkFileUri
}

Java

import android.net.Uri;
import androidx.core.net.Uri;
import java.io.File;
...
import com.google.android.managementapi.commands.LocalCommandClient;
import com.google.android.managementapi.commands.LocalCommandClient.InstallCustomAppCommandHelper;
import com.google.android.managementapi.commands.LocalCommandClientFactory;

...

Uri prepareApkFile() {
  // Get the storage location of custom APK files from AM API
  LocalCommandClient client = LocalCommandClientFactory.create();
  InstallCustomAppCommandHelper installCustomAppCommandHelper = client.getInstallCustomAppCommandHelper();
  File customApksStorageDir = installCustomAppCommandHelper.getCustomApksStorageDirectory();

  // Once you get hold of the custom APKs storage directory, you must store your custom APK
  // in that location before issuing the install command.
  File customApkFile = fetchMyAppToDir(customApksStorageDir);
  Uri customApkFileUri = Uri.fromFile(customApkFile);
  ...
}

2.2. Inviare una richiesta di installazione di un'app personalizzata

Il seguente snippet mostra come inviare una richiesta per installare un'app personalizzata:

Kotlin

import android.content.Context
import android.net.Uri
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.IssueCommandRequest
import com.google.android.managementapi.commands.model.IssueCommandRequest.InstallCustomApp
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import kotlinx.coroutines.guava.await
import kotlinx.coroutines.withContext
import java.lang.Exception

private const val TAG = "MyClass"

...

    // Requires a file URI of the APK file.
    fun issueInstallCustomAppCommand(packageName: String, fileUri: Uri) {
        coroutineScope.launch {
            try {
                withContext(coroutineScope.coroutineContext) {
                    val result: Command = LocalCommandClientFactory.create(context)
                        .issueCommand(createInstallCustomAppRequest(packageName, fileUri)).await()
                    // Process the returned command result here.
                    Log.i(TAG, "Successfully issued command: $result")
                }
            } catch (t: Exception) {
                Log.e(TAG, "Failed to issue command", t)
                // Handle the exception (e.g., show an error message)
            } finally {
                // Make sure to clean up the apk file after the command is executed.
                cleanUpApkFile(fileUri)
            }
        }
    }

    private fun createInstallCustomAppRequest(packageName: String, fileUri: Uri): IssueCommandRequest {
        return IssueCommandRequest.builder()
            .setInstallCustomApp(
                InstallCustomApp.builder()
                    .setPackageName(packageName)
                    .setPackageUri(fileUri.toString())
                    .build()
            )
            .build()
    }
}

Java

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;

...

  // Requires a file URI of the APK file.
  void issueInstallCustomAppCommand(String packageName, Uri fileUri) {
    Futures.addCallback(
        LocalCommandClientFactory.create(getContext())
            .issueCommand(createInstallCustomAppRequest(packageName, fileUri)),
        new FutureCallback() {
          @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 createInstallCustomAppRequest(String packageName, Uri fileUri) {
    return IssueCommandRequest.builder()
        .setInstallCustomApp(
            InstallCustomApp.builder()
                .setPackageName(packageName)
                .setPackageUri(fileUri.toString())
                .build()
        )
        .build();
  }

2.3. Emettere una richiesta per ottenere le app installate

Kotlin

import android.content.Context
import com.google.android.managementapi.device.DeviceClientFactory
import com.google.android.managementapi.device.model.GetDeviceRequest
import kotlinx.coroutines.guava.await

  suspend fun getInstalledApps(context: Context) =
    DeviceClientFactory.create(context)
      .getDevice(GetDeviceRequest.getDefaultInstance())
      .await()
      .getApplicationReports()

Java

import android.content.Context;
import com.google.android.managementapi.device.DeviceClientFactory;
import com.google.android.managementapi.device.model.GetDeviceRequest;
import com.google.android.managementapi.device.model.Device;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.List;
import java.util.concurrent.Executor;

public ListenableFuture<List> getInstalledApps() {
        ListenableFuture deviceFuture =
            DeviceClientFactory.create(context)
                .getDevice(GetDeviceRequest.getDefaultInstance());

        return Futures.transform(
            deviceFuture,
            Device::getApplicationReports,
            executor // Use the provided executor
        );
    }

3. Esegui il provisioning del dispositivo con criteri di gestione delle app personalizzati

  1. Configura un policy con le app personalizzate che intendi gestire.

      {
    "statusReportingSettings": {
      "applicationReportsEnabled": true
    },
    "applications": [
    {
      "signingKeyCerts": [
        {
        "signingKeyCertFingerprintSha256": <sha256 signing key certificate hash value>
        }
      ],
      "packageName": "<emm_extensibility_app>",
      "installType": "AVAILABLE",
      "lockTaskAllowed": true,
      "defaultPermissionPolicy": "GRANT",
      "extensionConfig": {
          "notificationReceiver": "com.example.customapp.NotificationReceiverService"
      }
    },
    {
      "signingKeyCerts": [
        {
        "signingKeyCertFingerprintSha256": <sha256 signing key certificate hash value>
        },
      ],
      "packageName": "<custom_app>",
      "installType": "CUSTOM",
      "lockTaskAllowed": true,
      "defaultPermissionPolicy": "GRANT",
      "customAppConfig": {
    "userUninstallSettings": "DISALLOW_UNINSTALL_BY_USER"
      }
    }
    ]
  }
  ```

  2. Crea un token di registrazione per il dispositivo chiamando enterprises.enrollmentTokens.create, con allowPersonalUsage impostato su PERSONAL_USAGE_DISALLOWED.

  3. Esegui il provisioning del dispositivo in modalità completamente gestita con il token di registrazione.

  4. Installa l'app di estensibilità da Google Play gestito.

  5. La tua app di estendibilità:

    • può scaricare il file APK dell'app personalizzata
    • può inviare una richiesta per installare l'app personalizzata (fai riferimento allo snippet di codice mostrato in precedenza)
    • dovresti ricevere una risposta

API

API server-client

Fai riferimento ai nuovi campi e alle nuove enumerazioni elencati: