Configurer un worker pour l'importation de profils

ProfilingManager enregistre les traces localement sur l'appareil. Bien que vous puissiez récupérer ces fichiers à l'aide d'ADB pour le débogage local, la collecte de données sur le terrain nécessite de les importer sur un serveur.

Les fichiers de trace peuvent être volumineux (souvent plusieurs Mo). Pour éviter d'affecter négativement l'expérience utilisateur ou de consommer des données mobiles, vous devez planifier les importations pour qu'elles se produisent en arrière-plan, de préférence lorsque l'appareil est sur un réseau non facturé à l'usage (Wi-Fi), en charge et inactif.

Configurer une tâche d'importation WorkManager

ProfilingManager est indépendant du cloud. Vous pouvez importer des traces dans l'infrastructure de votre choix. L'exemple suivant montre comment utiliser WorkManager pour planifier un job d'importation qui n'interrompt pas l'utilisateur.

Exemple de code pour configurer un job d'importation

Voici un exemple de configuration d'un job non perturbant pour l'utilisateur afin d'importer des traces sur votre serveur.

Ajouter des dépendances WorkManager

En plus de vos dépendances ProfilingManager existantes, ajoutez ces bibliothèques Jetpack à votre fichier build.gradle.kts. WorkManager en a besoin.

Kotlin

   dependencies {
       implementation("androidx.work:work-runtime:2.11.0")
   }

Groovy

   dependencies {
       implementation 'androidx.work:work-runtime:2.11.0'
   }

Extrait de code

Ce code montre comment configurer un job pour importer des traces. Le job doit être configuré lorsque ProfilingResult est reçu par votre application. La section sur le profilage est omise dans cette section, mais un exemple est disponible dans Enregistrer une trace système.

Kotlin

class TraceUploadWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
        // Perform your uploading work here
        Log.d("ProfileTest", "Uploading trace: " + inputData.getString("PROFILE_PATH"))

        return Result.success()
    }
}

fun setupProfileUploadWorker(profileFilepath: String?) {
    val workMgr = WorkManager.getInstance(applicationContext)
    val workRequestBuilder = OneTimeWorkRequest.Builder(TraceUploadWorker::class)

    val constraints = Constraints.Builder()
        .setRequiredNetworkType(NetworkType.UNMETERED)
        .setRequiresDeviceIdle(true)
        .setRequiresCharging(true)
        .build()
    workRequestBuilder.setConstraints(constraints)

    val inputDataBuilder = Data.Builder()
    inputDataBuilder.putString("PROFILE_PATH", profileFilepath)
    workRequestBuilder.setInputData(inputDataBuilder.build())

    workMgr.enqueue(workRequestBuilder.build())
}
ProfilingManagerKotlinSnippets.kt

Java

public static class TraceUploadWorker extends Worker {

  public TraceUploadWorker(
      @androidx.annotation.NonNull Context context,
      @androidx.annotation.NonNull WorkerParameters workerParams) {
    super(context, workerParams);
  }

  @androidx.annotation.NonNull
  @Override
  public Result doWork() {
    // Perform your uploading work here
    Log.d("ProfileTest", "Uploading trace: " + getInputData().getString("PROFILE_PATH"));

    return Result.success();
  }
}

public void setupProfileUploadWorker(String profileFilepath) {
  WorkManager workMgr = WorkManager.getInstance(getApplicationContext());
  OneTimeWorkRequest.Builder workRequestBuilder = new OneTimeWorkRequest.Builder(
      TraceUploadWorker.class);

  Constraints constraints = new Constraints.Builder()
      .setRequiredNetworkType(NetworkType.UNMETERED)
      .setRequiresDeviceIdle(true)
      .build();
  workRequestBuilder.setConstraints(constraints);

  Data.Builder inputDataBuilder = new Data.Builder();
  inputDataBuilder.putString("PROFILE_PATH", profileFilepath);
  workRequestBuilder.setInputData(inputDataBuilder.build());

  workMgr.enqueue(workRequestBuilder.build());
}
ProfilingManagerJavaSnippets.java

Tutoriel du code

Le code effectue les opérations suivantes :

  • Définissez le worker : créez une classe TraceUploadWorker étendant Worker. Implémentez la méthode doWork() pour gérer la logique d'importation de fichier à l'aide du SDK de backend ou du client HTTP de votre choix.

  • Profilage des requêtes : utilisez SystemTraceRequestBuilder pour configurer la trace (durée, stratégie de mémoire tampon) et Profiling.requestProfiling pour la démarrer.

  • Planifiez le travail :

    • Créez un OneTimeWorkRequest pour votre employé.

    • Définissez des contraintes : utilisez setRequiredNetworkType(NetworkType.UNMETERED), setRequiresDeviceIdle(true) et setRequiresCharging(true) pour vous assurer que l'importation n'a lieu que lorsque l'utilisateur est connecté au Wi-Fi, que l'appareil est en charge et qu'il n'est pas utilisé activement. Cela permet d'éviter d'interrompre l'utilisateur pendant le job d'importation.

    • Transmettre des données : utilisez setInputData pour transmettre le chemin de trace au nœud de calcul.

    • Mise en file d'attente : envoyez la requête à WorkManager en appelant WorkManager#enqueue.

Étapes suivantes

Une fois les traces importées, vous pouvez les analyser individuellement ou effectuer une analyse groupée des traces. Pour obtenir des conseils sur la configuration d'un pipeline d'analyse évolutif, consultez Déployer Bigtrace sur Kubernetes.