Configura un trabajador para la carga de perfiles

ProfilingManager guarda los registros 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 registro pueden ser grandes (a menudo, de 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 ilimitada (Wi-Fi), se esté cargando y esté inactivo.

Cómo configurar un trabajo de carga de WorkManager

ProfilingManager es independiente de la nube, por lo que puedes subir registros a cualquier infraestructura que elijas. En el siguiente ejemplo, se muestra cómo usar WorkManager para programar un trabajo de carga que no interrumpa a los usuarios.

Ejemplo de código para configurar un trabajo de carga

Este es un ejemplo de cómo puedes configurar un trabajo que no interrumpa al usuario para subir registros 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 los necesita.

Kotlin

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

Groovy

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

Fragmento de código

En este código, se muestra cómo configurar un trabajo para subir registros. El trabajo se debe configurar cuando tu app recibe el objeto ProfilingResult. En esta sección, se omite la sección de generación de perfiles, pero puedes encontrar un ejemplo en Cómo registrar un registro 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())
}
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

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 tu SDK de backend o cliente HTTP preferido.

  • Perfil de solicitudes: Usa SystemTraceRequestBuilder para configurar el registro (duración, política de búfer) y Profiling.requestProfiling para iniciarlo.

  • Programa el trabajo:

    • Crea un OneTimeWorkRequest para tu trabajador.

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

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

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

Próximos pasos

Después de subir los registros, puedes analizarlos de forma individual o realizar un análisis masivo de registros. Si necesitas orientación para configurar una canalización de análisis escalable, consulta Implementa Bigtrace en Kubernetes.