In questa lezione parleremo dell’importanza degli AsynchTask in Android e vedremo come implementarne uno.
[divider]
Perchè usare un AsynchTask
A volte sviluppando un’app per Android abbiamo bisogno di compiere operazioni molto pesanti o la cui durata è difficilmente prevedibile. Facciamo l’esempio di dover scaricare un’immagine dalla rete e renderla visibile all’utente, questa azione può essere compiuta in qualche attimo o in diversi secondi a seconda del dispositivo, connessione, grandezza del file, ecc… Altro caso simile potrebbe essere l’ottenimento delle coordinate tramite GPS. Queste azioni “impallano” l’interfaccia utente, e andrebbero svolte sempre in background. Android ci viene in aiuto fornendoci la classe AsynchTask.
[divider]
Implementazione di un AsynchTask
Creiamo un nuovo progetto su Eclipse, chiamandolo “Esempio AsynchTask”. La nostra interfaccia sarà semplice e conterrà solo un button Start per far partire il task in background:
Passiamo alla parte Java. Definiamo un nuovo AsynchTask direttamente dentro la nostra classe principale, ed implementiamo 2 suoi metodi ( doInBackground() e onPostExecute() ):
public class MyTask extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... params) {
//Ci "addormentiamo" per un tempo scelto a random
Random r = new Random();
int intervallo = r.nextInt(10)+1;//da 1 a 10
try {
//Dormiamo da 1 a 10 secondi
Thread.sleep(intervallo*1000);
} catch (InterruptedException e) {
//Eseguiremo questo codice se il processo viene interrotto brutalmente
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(Void result) {
progressdialog.cancel();
super.onPostExecute(result);
return;
}
}
Analizziamo il codice: Una volta lanciato il nostro task eseguirà il codice del metodo “doInBackground()”. Per simulare un processo che impiega un tempo indeterminato per essere eseguito utilizziamo la classe Random di Java (l’abbiamo già vista in questa lezione). Thread.sleep() ci permette di aspettare un tempo definito prima di continuare l’esecuzione. Il try-catch è un costrutto del Java per gestire eventuali crash anomali dovuti al metodo sleep, non fateci troppo caso. Da notare invece il codice del metodo “onPostExecute()” che verrà eseguito dopo l’esecuzione in background. Nel nostro caso questo semplicemente farà scomparire la dialog di attesa (che definiremo nella onCreate()).
Il codice completo della classe ActivityMain è il seguente:
package com.example.esempioasynchtask;
import java.util.Random;
import android.app.Activity;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity {
Button b;
ProgressDialog progressdialog;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
b = (Button) findViewById(R.id.button1);
b.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
progressdialog = ProgressDialog.show(MainActivity.this,"Esecuzione","Attendere Prego");
progressdialog.show();
MyTask t = new MyTask();
t.execute();
}
});
}
public class MyTask extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... params) {
//Ci "addormentiamo" per un tempo scelto a random
Random r = new Random();
int intervallo = r.nextInt(10)+1;//da 1 a 10
try {
//Dormiamo da 1 a 10 secondi
Thread.sleep(intervallo*1000);
} catch (InterruptedException e) {
//Eseguiremo questo codice se il processo viene interrotto brutalmente
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(Void result) {
progressdialog.cancel();
super.onPostExecute(result);
return;
}
}
}
Al click sul tasto Start visualizzeremo un messaggio di attesa (che faremo scomparire alla fine dell’esecuzione) e faremo partire il task (t.execute()).
Vi lasciamo anche il link per scaricare il progetto completo da qui.
Per le altre lezioni visualizza l’indice del corso di programmazione avanzata.
