Administra apps personalizadas con AMAPI

Como EMM basado en la API de Android Management, puedes administrar de forma remota aplicaciones personalizadas en dispositivos. Esto incluye la instalación y desinstalación de estas apps. Esta funcionalidad se logra desarrollando una app de extensión de forma local con el SDK de la AMAPI.

Requisitos previos

1. Prepara tu app para usar la función

1.1. Integra el SDK de la AMAPI en la app de extensión

El proceso de administración de apps personalizadas requiere que integres el SDK de la AMAPI en tu app de extensión. Puedes encontrar más información sobre esta biblioteca y cómo agregarla a tu app en la guía de integración del SDK de la AMAPI.

1.2. Actualiza el manifiesto de tu app para admitir FileProvider

  • Agrega a tu AndroidManifest.xml el elemento <queries> para la aplicación de Android Device Policy (ADP), como se muestra en la guía de integración del SDK de AMAPI.
  • Implementa el siguiente fragmento de <provider> en el AndroidManifest.xml de tu app dentro de la etiqueta <application>. Este fragmento se usa para almacenar archivos cuando se comparte el APK de la app personalizada, lo que permite la instalación de apps personalizadas con la 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 archivo XML nuevo en el directorio res/xml/ de tu app que contenga la ruta de almacenamiento de los APKs personalizados.

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. Integración con la función de apps personalizadas del SDK de la AMAPI

2.1. Prepara el archivo APK personalizado para la instalación

Antes de la implementación, se debe preparar el archivo APK de la aplicación para la instalación. En el siguiente fragmento de código, se muestra el proceso:

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. Cómo emitir una solicitud para instalar una app personalizada

En el siguiente fragmento, se muestra cómo emitir una solicitud para instalar una app personalizada:

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. Cómo emitir una solicitud para obtener las apps instaladas

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. Aprovisiona el dispositivo con políticas de administración de apps personalizadas

  1. Configura un objeto policy con las apps personalizadas que deseas administrar.

      {
    "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. Llama a enterprises.enrollmentTokens.create para crear un token de inscripción para el dispositivo y establece allowPersonalUsage en PERSONAL_USAGE_DISALLOWED.

  3. Aprovisiona el dispositivo en el modo completamente administrado con el token de inscripción.

  4. Instala tu app de extensibilidad desde Managed Play.

  5. Tu app de extensibilidad:

    • Puede descargar el archivo APK de la app personalizada.
    • puede emitir una solicitud para instalar la app personalizada (consulta el fragmento de código que se mostró anteriormente)
    • debería recibir una respuesta

API

API de cliente-servidor

Consulta los nuevos campos y enumeraciones que se indican a continuación: