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 en arrière-plan, de préférence lorsque l'appareil est connecté à un réseau sans compteur (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 une tâche d'importation qui n'interrompt pas l'utilisateur.

Exemple de code pour configurer une tâche d'importation

Voici un exemple de configuration d'une tâche qui n'interrompt pas l'utilisateur pour 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.2")
   }

Groovy

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

Extrait de code

Ce code montre comment configurer une tâche d'importation de traces. La tâche doit être configurée lorsque ProfilingResult est reçu par votre application. La section de profilage est omise dans cette section, mais vous trouverez un exemple 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())
}

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

Tutoriel du code

Le code :

  • Définir le nœud de calcul : créez une classe TraceUploadWorker qui étend Worker. Implémentez la méthode doWork() pour gérer la logique d'importation de fichiers réelle à l'aide du SDK backend ou du client HTTP de votre choix.

  • Demander le profilage : utilisez SystemTraceRequestBuilder pour configurer la trace (durée, stratégie de mémoire tampon) et Profiling.requestProfiling pour la démarrer.

  • Planifier le travail :

    • Créez une OneTimeWorkRequest pour votre nœud de calcul.

    • 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 ne l'utilise pas activement. Cela est important pour éviter d'interrompre l'utilisateur avec la tâche d'importation.

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

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

Étapes suivantes

Après avoir importé des traces, 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.