studio - Android: ¿Cómo puedo pasar parámetros a OnPreExecute() de AsyncTask?

oncancelled asynctask android

Question

Utilizo AsyncTask para cargar operaciones que implementé como una clase interna.

En onPreExecute() , muestro un diálogo de carga que luego onPostExecute() nuevamente en onPostExecute() . Pero para algunas de las operaciones de carga sé de antemano que terminarán muy rápido, así que no quiero mostrar el cuadro de diálogo de carga.

Quería indicar esto mediante un parámetro booleano que podría pasar a onPreExecute() pero aparentemente por algún motivo onPreExecute() no toma ningún parámetro.

La solución obvia probablemente sería crear un campo miembro en mi AsyncTask o en la clase externa, que tendría que configurar antes de cada operación de carga, pero eso no parece muy elegante. ¿Hay una mejor manera de hacer esto?

Answer 1

Por qué, cómo y qué parámetros se pasan a Asynctask <>, vea los detalles here . Creo que es la mejor explicación.

La documentación de Android de Google dice que:

Una tarea asincrónica está definida por 3 tipos genéricos, llamados Params, Progress y Result, y 4 pasos, llamados onPreExecute, doInBackground, onProgressUpdate y onPostExecute.

Tipos genéricos de AsyncTask:

Los tres tipos utilizados por una tarea asincrónica son los siguientes:

Params, el tipo de parámetros enviados a la tarea en la ejecución. Progreso, el tipo de unidades de progreso publicadas durante el cálculo de fondo. Resultado, el tipo del resultado del cálculo de fondo. No todos los tipos son siempre utilizados por una tarea asincrónica. Para marcar un tipo como no utilizado, simplemente use el tipo Void:

 private class MyTask extends AsyncTask<Void, Void, Void> { ... }

Puede consultar más detalles: http://developer.android.com/reference/android/os/AsyncTask.html

O puede aclarar cuál es el papel de AsyncTask al referirse al Blog de Sankar-Ganesh

Bueno, la estructura de una clase AsyncTask típica es la siguiente:

private class MyTask extends AsyncTask<X, Y, Z>

    protected void onPreExecute(){ 

    } 

Este método se ejecuta antes de iniciar el nuevo subproceso. No hay valores de entrada / salida, así que simplemente inicialice las variables o lo que sea que crea que necesita hacer.

protected Z doInBackground(X...x){

}

El método más importante en la clase AsyncTask. Debe colocar aquí todas las cosas que desea hacer en segundo plano, en un hilo diferente del principal. Aquí tenemos como valor de entrada una matriz de objetos del tipo "X" (¿Ves en el encabezado? Tenemos "... extends AsyncTask" Estos son los TIPOS de los parámetros de entrada) y devuelve un objeto del tipo "Z".

nulo protegido onProgressUpdate (Y y) {

} Este método se llama utilizando el método publishProgress (y) y generalmente se usa cuando desea mostrar cualquier progreso o información en la pantalla principal, como una barra de progreso que muestra el progreso de la operación que está realizando en segundo plano.

void protegido onPostExecute (Z z) {

} Este método se invoca después de que se realiza la operación en segundo plano. Como parámetro de entrada, recibirá el parámetro de salida del método doInBackground.

¿Qué pasa con los tipos X, Y y Z?

Como se puede deducir de la estructura anterior:

X – The type of the input variables value you want to set to the background process. This can be an array of objects.

 Y – The type of the objects you are going to enter in the onProgressUpdate method.

 Z – The type of the result from the operations you have done in the background process.

¿Cómo llamamos a esta tarea desde una clase externa? Solo con las siguientes dos líneas:

MyTask myTask = new MyTask();

myTask.execute(x);

Donde x es el parámetro de entrada del tipo X.

Una vez que tenemos nuestra tarea en ejecución, podemos averiguar su estado desde "afuera". Usando el método "getStatus ()".

myTask.getStatus (); y podemos recibir el siguiente estado:

EJECUTANDO: indica que la tarea se está ejecutando.

PENDIENTE - Indica que la tarea aún no se ha ejecutado.

ACABADO - Indica que onPostExecute (Z) ha terminado.

Consejos sobre el uso de AsyncTask

No invoque manualmente los métodos onPreExecute, doInBackground y onPostExecute. Esto es hecho automáticamente por el sistema.

No puede llamar a una AsyncTask dentro de otra AsyncTask o Thread. La llamada de la ejecución del método debe realizarse en el subproceso UI.

El método onPostExecute se ejecuta en el subproceso UI (aquí puede llamar a otro AsyncTask!).

Los parámetros de entrada de la tarea pueden ser una matriz de Objetos, de esta manera puede colocar los objetos y tipos que desee.

Answer 2

Puede anular el constructor. Algo como:

private class MyAsyncTask extends AsyncTask<Void, Void, Void> {

    public MyAsyncTask(boolean showLoading) {
        super();
        // do stuff
    }

    // doInBackground() et al.
}

Luego, cuando llame a la tarea, haga algo como:

new MyAsyncTask(true).execute(maybe_other_params);

Editar: esto es más útil que crear variables miembro porque simplifica la invocación de tareas. Compare el código de arriba con:

MyAsyncTask task = new MyAsyncTask();
task.showLoading = false;
task.execute();

Answer 3

Puede pasar el parámetro en el constructor de la tarea o cuando llame ejecutar:

AsyncTask<Object, Void, MyTaskResult>

El primer parámetro (Object) se pasa en doInBackground. El tercer parámetro (MyTaskResult) es devuelto por doInBackground. Puede cambiarlos a los tipos que desee. Los tres puntos significan que cero o más objetos (o una matriz de ellos) se pueden pasar como argumento (s).

public class MyActivity extends AppCompatActivity {

    TextView textView1;
    TextView textView2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);    
        textView1 = (TextView) findViewById(R.id.textView1);
        textView2 = (TextView) findViewById(R.id.textView2);

        String input1 = "test";
        boolean input2 = true;
        int input3 = 100;
        long input4 = 100000000;

        new MyTask(input3, input4).execute(input1, input2);
    }

    private class MyTaskResult {
        String text1;
        String text2;
    }

    private class MyTask extends AsyncTask<Object, Void, MyTaskResult> {
        private String val1;
        private boolean val2;
        private int val3;
        private long val4;


        public MyTask(int in3, long in4) {
            this.val3 = in3;
            this.val4 = in4;

            // Do something ...
        }

        protected void onPreExecute() {
            // Do something ...
        }

        @Override
        protected MyTaskResult doInBackground(Object... params) {
            MyTaskResult res = new MyTaskResult();
            val1 = (String) params[0];
            val2 = (boolean) params[1];

            //Do some lengthy operation    
            res.text1 = RunProc1(val1);
            res.text2 = RunProc2(val2);

            return res;
        }

        @Override
        protected void onPostExecute(MyTaskResult res) {
            textView1.setText(res.text1);
            textView2.setText(res.text2);

        }
    }

}

Answer 4

1) Para mí esa es la manera más simple de pasar los parámetros a la tarea asincrónica, es como esto

// To call the async task do it like this
Boolean[] myTaskParams = { true, true, true };
myAsyncTask = new myAsyncTask ().execute(myTaskParams);

Declara y usa la tarea asincrónica como aquí

private class myAsyncTask extends AsyncTask<Boolean, Void, Void> {

    @Override
    protected Void doInBackground(Boolean...pParams) 
    {
        Boolean param1, param2, param3;

        //

          param1=pParams[0];    
          param2=pParams[1];
          param3=pParams[2];    
      ....
}                           

2) Pasar métodos a async-task Para evitar codificar la infraestructura async-Task (thread, messagenhandler, ...) varias veces, puede considerar pasar los métodos que deberían ejecutarse en su async-task como parámetro. El siguiente ejemplo describe este enfoque. Además, puede tener la necesidad de crear una subclase de la tarea asíncrona para pasar los parámetros de inicialización en el constructor.

 /* Generic Async Task    */
interface MyGenericMethod {
    int execute(String param);
}

protected class testtask extends AsyncTask<MyGenericMethod, Void, Void>
{
    public String mParam;                           // member variable to parameterize the function
    @Override
    protected Void doInBackground(MyGenericMethod... params) {
        //  do something here
        params[0].execute("Myparameter");
        return null;
    }       
}

// to start the asynctask do something like that
public void startAsyncTask()
{
    // 
    AsyncTask<MyGenericMethod, Void, Void>  mytest = new testtask().execute(new MyGenericMethod() {
        public int execute(String param) {
            //body
            return 1;
        }
    });     
}