Implementando AsyncTasks

O AsyncTask é uma interface que o Android fornece para que os desenvolvedores possam lançar operações bloqueantes em uma nova thread, na qual executará a requisição e retornará o resultado à thread principal, sem que essa seja bloqueada e sem a necessidade do desenvolvedor tratar eventos de comunicação assíncrona.

A utilização dessa classe é simples. Implemente uma subclasse privada em sua Activity que implemente os métodos doInBackground() e onPostExecute(). Esses métodos são os responsáveis por executar as requisições em uma thread separada em background e atualizar a thread principal, respectivamente. Uma vez implementados, basta chamar o método execute() dessa subclasse em sua Activity e a requisição será processada, de forma assíncrona. Vejamos a Listagem 8 para entender melhor como funciona esse processo. Implementaremos o mesmo código do exemplo anterior, apenas omitindo os métodos de conexão que se manterão iguais.

x
1
public class HTTPURLCommunication extends Activity {
2
    private static String ENDERECO ="http://10.0.2.2:8080/aula14/ServletHello"; 
3
4
    Context context = getApplicationContext();
5
    @Override
6
    protected void onCreate(Bundle savedInstanceState) { 
7
        super.onCreate(savedInstanceState); 
8
        setContentView(R.layout.main); 
9
        new Requisicoes().execute("Aluno"); 
10
    } 
11
    public static String connect() { 
12
        ... 
13
    } 
14
    public static String connect(String id) { 
15
        ... 
16
    } 
17
18
    private class Requisicoes extends AsyncTask<String, Void, String> { 
19
        protected String doInBackground(String... id) { 
20
            return connect(id[0]); 
21
        } 
22
        protected void onPostExecute(String result) { 
23
            Toast.makeText(context, result, Toast.LENGTH_LONG).show(); 
24
        } 
25
    } 
26
}
Listagem 8 - Fazendo requisições em segundo plano através da classe AsyncTask.

Perceba que a classe AsyncTask precisa de três tipos em sua declaração. Esses tipos são o tipo dos parâmetros, o tipo do progresso e o tipo do resultado final. O tipo do progresso raramente é utilizado. Ele serve para determinar que tipo será retornado quando houver progresso na requisição que a thread está executando. Já os outros dois parâmetros são extremamente importantes. O primeiro deles indica o tipo dos parâmetros que o método doInBackground() receberá para utilizar na requisição. O último declara o tipo do objeto que será retornado pelo método doInBackground(). O retorno desse método é automaticamente passado como parâmetro para o método onPostExecute(), então, podemos dizer que esse valor é também o tipo do parâmetro do método onPostExecute(). Com essas informações, você deve ser capaz de implementar requisições a serem executadas em segundo plano, da maneira que todas as conexões dentro de uma aplicação devem ser feitas.

É importante notar que sempre que precisarmos utilizar o valor retornado pela requisição, deveremos fazer isso dentro do método onPostExecute(), pois como a requisição será executada em outra thread, a thread principal vai continuar e pode terminar por utilizar o valor antes de ele terminar de ser obtido na outra thread, o que vai gerar um erro. Já no caso do valor ser utilizado somente dentro do onPostExecute(), podemos ter certeza de que ele só será chamado após a execução completa da requisição solicitada. Com esse conhecimento sobre como as requisições web devem ser feitas dentro de uma aplicação Android, encerramos a nossa aula. Até a próxima, que será nossa última!

play_circle_filled
Vídeo 04 - Restful Webservices

Versão 5.3 - Todos os Direitos reservados