Configura un trabajador para la carga de perfiles

ProfilingManager guarda los seguimientos de forma local en el dispositivo. Si bien puedes recuperar estos archivos con ADB para la depuración local, la recopilación de datos de campo requiere que los subas a un servidor.

Los archivos de seguimiento pueden ser grandes (a menudo, varios MB). Para evitar afectar negativamente la experiencia del usuario o consumir datos móviles, debes programar las cargas para que se realicen en segundo plano, de preferencia cuando el dispositivo esté en una red no medida (Wi-Fi), cargándose y sin actividad.

Configura un trabajo de carga de WorkManager

ProfilingManager es independiente de la nube; puedes subir seguimientos a cualquier infraestructura que elijas. En el siguiente ejemplo, se muestra cómo usar WorkManager para programar un trabajo de carga que evite la interrupción del usuario.

Ejemplo de código para configurar un trabajo de carga

Aquí se incluye un ejemplo de cómo puedes configurar un trabajo que no interrumpa al usuario para subir seguimientos a tu servidor.

Agrega dependencias de WorkManager

Además de las dependencias existentes de ProfilingManager, agrega estas bibliotecas de Jetpack a tu archivo build.gradle.kts. WorkManager las necesita.

Kotlin

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

Groovy

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

Fragmento de código

En este código, se muestra cómo configurar un trabajo para subir seguimientos. El trabajo se debe configurar cuando tu app reciba el ProfilingResult. La sección de generación de perfiles se omite en esta sección, pero puedes encontrar un ejemplo en Registra un seguimiento del sistema.

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

Explicación del código

El código hace lo siguiente:

  • Define el trabajador: Crea una clase TraceUploadWorker que extienda Worker. Implementa el método doWork() para controlar la lógica de carga de archivos real con el SDK de backend o el cliente HTTP que prefieras.

  • Solicita la generación de perfiles: Usa SystemTraceRequestBuilder para configurar el seguimiento (duración, política de búfer) y Profiling.requestProfiling para iniciar lo.

  • Programa el trabajo:

    • Crea una OneTimeWorkRequest para tu trabajador.

    • Establece restricciones: Usa setRequiredNetworkType(NetworkType.UNMETERED), setRequiresDeviceIdle(true) y setRequiresCharging(true) para asegurarte de que la carga solo se realice cuando el usuario esté conectado a Wi-Fi, cargando y no usando el dispositivo de forma activa. Esto es importante para evitar interrumpir al usuario con el trabajo de carga.

    • Pasa datos: Usa setInputData para pasar la ruta de seguimiento al trabajador.

    • Pon en cola: Envía la solicitud a WorkManager llamando a WorkManager#enqueue.

Próximos pasos

Después de subir los seguimientos, puedes analizarlos de forma individual o realizar un análisis masivo de seguimientos. Para obtener orientación sobre cómo configurar una canalización de análisis escalable, consulta Implementa Bigtrace en Kubernetes.