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 un job 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 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.12.0")
   }

Groovy

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

Extrait de code

Ce code montre comment configurer un job pour importer des traces. La tâche doit être configurée lorsque le 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 à l'aide du SDK de backend ou du client HTTP de votre choix.

  • Demander le profilage : utilisez SystemTraceRequestBuilder pour configurer la trace (durée, règle de mise en mémoire tampon) et Profiling.requestProfiling pour la démarrer.

  • Planifier le travail :

    • Créez un 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 n'est pas utilisé. Cela est important pour éviter de perturber l'utilisateur avec 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

Après avoir importé des traces, vous pouvez les analyser individuellement ou effectuer une analyse groupée des traces. Pour savoir comment configurer un pipeline d'analyse évolutif, consultez Déployer Bigtrace sur Kubernetes.