Não entendo o que devo colocar aqui e onde esses argumentos acabam? O que exatamente devo colocar e para onde exatamente ele irá? Preciso incluir todos os 3 ou posso incluir 1,2,20?

A documentação para Android do Google diz que:

Uma tarefa assíncrona é definida por 3 tipos genéricos, chamados Params, Progress e Result, e 4 etapas, chamadas onPreExecute, doInBackground, onProgressUpdate e onPostExecute.

Tipos genéricos do AsyncTask:

Os três tipos usados ​​por uma tarefa assíncrona são os seguintes:

Params, the type of the parameters sent to the task upon execution.
Progress, the type of the progress units published during the background computation.
Result, the type of the result of the background computation.

Nem todos os tipos são sempre usados ​​por uma tarefa assíncrona. Para marcar um tipo como não utilizado, basta usar o tipo Void:

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

Você também pode consultar: http://developer.android.com/reference/android/os/AsyncTask.html

Ou você pode esclarecer qual é o papel do AsyncTask consultando o Blog da Sankar-Ganesh

Bem A estrutura de uma classe AsyncTask típica é semelhante a:

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

    protected void onPreExecute(){

    }

Este método é executado antes de iniciar o novo Thread. Não há valores de entrada / saída, portanto, basta inicializar variáveis ​​ou o que você acha que precisa fazer.

    protected Z doInBackground(X...x){

    }

O método mais importante na classe AsyncTask. Você deve colocar aqui todas as coisas que deseja fazer em segundo plano, em um segmento diferente do principal. Aqui temos como valor de entrada uma matriz de objetos do tipo “X” (você vê no cabeçalho? Nós temos “... extends AsyncTask” Estes são os TIPOS dos parâmetros de entrada) e retorna um objeto do tipo "Z".

   protected void onProgressUpdate(Y y){

   }

Esse método é chamado usando o método publishProgress (y) e geralmente é usado quando você deseja mostrar qualquer progresso ou informação na tela principal, como uma barra de progresso que mostra o progresso da operação que está sendo executada em segundo plano.

  protected void onPostExecute(Z z){

  }

Este método é chamado após a conclusão da operação em segundo plano. Como parâmetro de entrada, você receberá o parâmetro de saída do método doInBackground.

E os tipos X, Y e Z?

Como você pode deduzir da estrutura acima:

 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.

Como chamamos essa tarefa de uma classe externa? Apenas com as duas linhas a seguir:

MyTask myTask = new MyTask();

myTask.execute(x);

Onde x é o parâmetro de entrada do tipo X.

Assim que tivermos nossa tarefa em execução, podemos descobrir seu status de "fora". Usando o método "getStatus ()".

 myTask.getStatus();

e podemos receber o seguinte status:

EXECUTANDO - Indica que a tarefa está em execução.

PENDENTE - Indica que a tarefa ainda não foi executada.

FINISHED - Indica que onPostExecute (Z) foi concluído.

Dicas sobre o uso do AsyncTask

1. Não chame os métodos onPreExecute, doInBackground e onPostExecute manualmente. Isso é feito automaticamente pelo sistema.

2. Você não pode chamar um AsyncTask dentro de outro AsyncTask ou Thread. A chamada do método execute deve ser feita no thread da interface do usuário.

3. O método onPostExecute é executado no thread da interface do usuário (aqui você pode chamar outra AsyncTask!).

4. Os parâmetros de entrada da tarefa podem ser uma matriz de objetos, desta forma, você pode colocar quaisquer objetos e tipos que desejar.

Estou muito atrasado para a festa, mas achei que isso poderia ajudar alguém.

Mantenha simples!

Uma AsyncTasktarefa em segundo plano é executada no encadeamento em segundo plano. É preciso uma entrada , executa o progresso e fornece a saída .

ie AsyncTask<Input,Progress,Output>.

Na minha opinião, a principal fonte de confusão ocorre quando tentamos memorizar os parâmetros no arquivo AsyncTask.
A chave é não memorizar .
Se você pode visualizar o que sua tarefa realmente precisa fazer, escrever a AsyncTaskassinatura correta seria um pedaço de bolo.
Basta descobrir quais são suas entradas , progresso e saída e você estará pronto para prosseguir.

Por exemplo:

Coração do AsyncTask!

doInBackgound()método é o método mais importante de uma AsyncTaskporque

• Somente esse método é executado no encadeamento em segundo plano e publica dados no encadeamento da interface do usuário.
• Sua assinatura muda com os AsyncTaskparâmetros.

Então vamos ver o relacionamento

doInBackground()e onPostExecute(), onProgressUpdate()também estão relacionados

Mostre-me o código
Então, como vou escrever o código para DownloadTask?

DownloadTask extends AsyncTask<String,Integer,String>{

      @Override
      public void onPreExecute()
      {}

      @Override
      public String doInbackGround(String... params)
      {
               // Download code
               int downloadPerc = // calculate that
               publish(downloadPerc);

               return "Download Success";
      }

      @Override
      public void onPostExecute(String result)
      {
          super.onPostExecute(result);
      }

      @Override
      public void onProgressUpdate(Integer... params)
      {
             // show in spinner, access UI elements
      }

}

Como você irá executar esta tarefa

new DownLoadTask().execute("Paradise.mp3");

Consulte os seguintes links:

1. http://developer.android.com/reference/android/os/AsyncTask.html
2. http://labs.makemachine.net/2010/05/android-asynctask-example/

Você não pode passar mais de três argumentos; se quiser passar apenas 1 argumento, use void para os outros dois argumentos.

1. private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> 


2. protected class InitTask extends AsyncTask<Context, Integer, Integer>

Uma tarefa assíncrona é definida por uma computação executada em um encadeamento em segundo plano e cujo resultado é publicado no encadeamento da interface do usuário. Uma tarefa assíncrona é definida por 3 tipos genéricos, chamados Params, Progress e Result, e 4 etapas, chamadas onPreExecute, doInBackground, onProgressUpdate e onPostExecute.

KPBird

• Resumindo, existem 3 parâmetros no AsyncTask

  1. Parâmetros para Uso de Entrada em DoInBackground (Parâmetros String ...)

  2. parâmetros para mostrar o status do progresso usado no OnProgressUpdate (String ... status)

  3. parâmetros para uso do resultado no OnPostExcute (String ... result)

  Nota: - [O tipo de parâmetros pode variar dependendo da sua exigência]