Threads en Android

Aclarirem certs conceptes de threading aplicats a Android.

Referències:

• Android
• Android ListView

Conceptes previs

Utilitzant ExecutorService

La forma oficial d'utilitzar threads actualment a Java és emprar la llibreria java.util.concurrent.

Referències:

• Alternatives to AsyncTask: ExcecutorService
• Article sobre java.util.concurrent
• java.util.concurrent Summary
• Per ampliar: Java ExcecutorService tutorial.

Resumint, la forma recomanda actualment per executar un thread és aquesta:

ExecutorService executor = Executors.newSingleThreadExecutor();
 
executor.execute(new Runnable() {
    @Override
    public void run() {
 
        // Tasques en background (xarxa)
 
        Handler handler = new Handler(Looper.getMainLooper());
        handler.post(new Runnable() {
            @Override
            public void run() {
 
                // Tasques a la interfície gràfica (GUI)
 
            }
        });
    }
});

Executar operacions amb retard al UI thread

Si volem executar operacions en el UI Thread després d'un cert temps, aquest post clarifica com utilitzar un Handler i un Runnable.

Les tasques enviades al Handler s'executaran en el mateix thread on s'ha creat. Per tant, si estem en un thread secundari, podem crear un Handler que envii missatges al UI thread indicat que el seu Looper és el MainLooper:

final Handler handler1 = new Handler(Looper.getMainLooper());
handler1.postDelayed(r, 1000);

on r és un Runnable.

runOnUIThread

Seguint el què hem explicat, des d'un thread secundari no podem fer operacions sobre el UI. Si necessitem fer-ne, caldrà utilitzar:

• Activity.runOnUiThread que s'encarregarà d'executar el codi del Runnable en el UI thread.
• Handler: permet enviar messages a un thread. Un Message pot ser un objecte amb text i dades, però també poden ser porcions de codi que es poden executar de forma asíncrona quan el thread pugui.
  • Handler disposa de funcions com postDelayed que permet l'execució diferida d'un codi.

Teniu aquest article que explica força coses de com funcionen els objectes Handler, Looper, Message i altres.

Threads de comunicació

Una aplicació típica és la utilització de threads per a comunicació. Tal i com hem dit, no podem executar funcions que bloqueginen el mainUIthread d'Android, i les comunicacions ho fan en tant que esperen la resposta remota.

Posem aquest codi d'una crida HTTP en una funció getDataFromUrl que podem afegir a la nostra MainActivity. Aquí tens més info sobre llibreries per a crides HTTP en Java.

Si l'executem dins el MainThread ens saltarà una excepció NetworkOnMainThreadException. Per això necessitem el codi del thread de mes amunt per poder-la executar.

MainActivity.java

    String error = ""; // string field
    private String getDataFromUrl(String demoIdUrl) {
 
        String result = null;
        int resCode;
        InputStream in;
        try {
            URL url = new URL(demoIdUrl);
            URLConnection urlConn = url.openConnection();
 
            HttpsURLConnection httpsConn = (HttpsURLConnection) urlConn;
            httpsConn.setAllowUserInteraction(false);
            httpsConn.setInstanceFollowRedirects(true);
            httpsConn.setRequestMethod("GET");
            httpsConn.connect();
            resCode = httpsConn.getResponseCode();
 
            if (resCode == HttpURLConnection.HTTP_OK) {
                in = httpsConn.getInputStream();
 
                BufferedReader reader = new BufferedReader(new InputStreamReader(
                        in, "iso-8859-1"), 8);
                StringBuilder sb = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    sb.append(line).append("\n");
                }
                in.close();
                result = sb.toString();
            } else {
                error += resCode;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

Per poder-se connectar a internet, cal activar el permís Android d'accés a Internet:

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

APIs i JSON

Les crides a APIs externes ens retornaran objectes JSON que cal descodificar. Per exemple, pots provar https://api.myip.com per veure la teva IP. Des de la shell fariem:

$ curl https://api.myip.com
{"ip":"139.47.113.84","country":"Spain","cc":"ES"}

Es recomana aquest exemple per descodificar els missatges JSON.

$ curl https://randomfox.ca/floof/

Exercicis

Per si et resulta avorrit, mes feina (exercici optatiu):

Android i WebSockets

Per poder emprar la biblioteca de codi Java WebSockets en Android caldrà afegir algunes línies als arxius:

build.gradle.kts

dependencies {
    ...
    implementation(libs.websocket)
    ...
}

libs.versions.toml

[versions]
...
websocket = "1.5.7"
 
[libraries]
...
websocket = { group = 'org.java-websocket', name = "Java-WebSocket", version.ref = "websocket" }

Recordem que per poder-se connectar a internet, cal activar el permís Android d'accés a Internet:

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Un cop fet tot això podrem emprar les biblioteques Java WebSockets al nostre codi:

MainActivity.java

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft_6455;
import org.java_websocket.handshake.ServerHandshake;
 
...
 
    WebSocketClient client = null;
    URI location = "ws://mywsserver.com";
 
    try {
        client = new WebSocketClient(new URI(location), (Draft) new Draft_6455());
        client.connect();
    } catch (URISyntaxException e) { 
        e.printStackTrace(); 
        System.out.println("Error: " + location + " no és una direcció URI de WebSocket vàlida");
    }
 
    client.send("Hola! M'acabo de connectar");
 
...