Android Runnable Tutoriel et exemples

Tutoriel et exemples sur l'interface Runnable d'Android.

Dans ce cours, nous verrons l'interface Runnable et ses exemples d'utilisation.

Qu'est-ce que Runnable ?

En Java, l'interface Runnable est essentiellement une abstraction pour une commande exécutable.

Nous avons parlé de la [classe Thread] (https://camposha.info/android/thread) comme d'une construction de bas niveau de la concurrence pour Java et Android.

Une autre brique est le Runnable, une interface qui provient de l'API Java, et qui est destinée à spécifier et encapsuler le code destiné à être exécuté par une instance de thread Java ou toute autre classe qui gère ce Runnable.

C'est une interface et elle est définie dans le paquet java.lang et possède une méthode abstraite appelée run() que nous devons implémenter.

package java.lang;
public interface Runnable{
    public abstract void run();
}

Utilisation

L'interface Runnable est largement utilisée pour exécuter du code dans les Threads.
L'interface Runnable possède une méthode abstraite appelée run() :

public abstract void run ()

Normalement, vous implémentez cette méthode chaque fois que votre classe implémente l'interface Runnable.
La méthode sera alors appelée pour commencer à exécuter la partie active du code de la classe.

Disons que nous voulons utiliser Runnable comme mécanisme de threading. Commençons par implémenter l'interface. Ensuite, fournissez l'implémentation de la méthode run() :

public class MyRunnable implements Runnable {
    public void run(){
        Log.d("Generic","Running in the Thread " +
        Thread.currentThread().getId());
    }
}

Avec cela, notre sous-classe Runnable peut maintenant être passée à Thread et est exécutée indépendamment dans la ligne d'exécution concurrente :

    Thread thread = new Thread(new MyRunnable());
    thread.start();

Dans le code suivant, nous avons essentiellement créé la sous-classe Runnable de sorte qu'elle
implémente la méthode run() et puisse être passée et exécutée par un thread :

Interface Runnable Sous-classes indirectes

Runnable a beaucoup de sous-classes indirectes, donc nous n'en listons que quelques-unes :

Voyons maintenant quelques exemples :

Android Exemple Runnable étape par étape

Ceci est un exemple pour Android. Android utilise évidemment Java et l'interface Runnable existe depuis le niveau 1 de l'API.

Nous pouvons utiliser un Runnable avec un Service comme suit :

public class MyService extends Service implements Runnable{}

Cela nous obligera alors à implémenter la méthode abstraite run() à l'intérieur de cette classe :

 @Override
    public void run() {
    }

Et étant donné que c'est un Service, nous devrons également surcharger une autre méthode abstraite pour le Service appelée onBind().

 @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

Service est un composant Android qui possède des callbacks de cycle de vie. L'un d'eux est le onCreate(), une méthode qui est levée à chaque fois qu'un Service est créé.

Donc pour nous, à chaque fois que cela se produit, nous voulons créer un thread et le démarrer :

@Override
    public void onCreate() {
        super.onCreate();
        Thread myThead=new Thread(this);
        myThead.start();
    }

Ensuite, disons que je veux enregistrer quelques messages toutes les 1 seconde, ajoutez le code suivant à l'intérieur de la méthode run() :

        while (true)
        {
            try{

                Log.i(MY_TAG,"Distance in Light Years : "+spaceship_distance);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

Puis comme variables d'instance, ajoutez ce qui suit au-dessus de votre méthode onCreate() :

public static String MY_TAG="MY_SERVICE";
private int spaceship_distance=0;

Et bien c'est un exemple d'utilisation de Runnable avec Android. Si vous souhaitez que le Service s'exécute réellement : alors faites ce qui suit :

1. Enregistrez le Service dans le Manifest :

```java

```

Assurez-vous que vous spécifiez le nom de votre <code>Service</code> au lieu de <code>MonService</code>.</code></pre>
<ol start="2">
<li>Démarrez le <code>Service</code> dans la <code>MainActivity</code> :</li>
</ol>
<!-- 12 -->
<pre><code>```java
Intent i=new Intent(this,MyService.class);
startService(i);
```

Et c'est tout, un exemple d'interface android Runnable avec services.

Notez que parfois les gens utilisent Runnable de cette manière :

    @Override
    public void onCreate() {
        super.onCreate();

        new Thread(new Runnable() {
            @Override
            public void run() {
                ArrayList<Song> songs = scanSongs(ScanMusicService.this);
                LogUtils.d(songs);
                ToastUtils.showLongToast(songs.toString());
            }
        }).start();

    }

Exemples rapides de Runnable.

(a). Comment effectuer un HTTP GET avec HttpURLConnection et Runnable.

HttpURLConnection est notre classe réseau et nous permet d'effectuer notre requête HTTP GET.

D'autre part, Runnable est notre interface qui nous permettra d'exécuter notre requête HTTP GET en arrière-plan.

Vous commencez donc par implémenter l'interface Runnable, ce qui vous oblige à surcharger la méthode run().

C'est dans cette méthode run() que nous effectuons notre requête HTTP GET :

public class UrlRequest implements Runnable {
    ......
 @Override
    public void run() {
        try {
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            InputStream stream = connection.getInputStream();
            int responseCode = connection.getResponseCode();
            ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
            byte buffer[] = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = stream.read(buffer)) > 0) {
                responseBody.write(buffer, 0, bytesRead);
            }
            listener.onReceivedBody(responseCode, responseBody.toByteArray());
        }
        catch (Exception e) {
            listener.onError(e);
        }
    }
}

Voici la classe complète :

import android.support.annotation.NonNull;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UrlRequest implements Runnable {

    public interface Listener {

        void onReceivedBody(int responseCode, byte body[]);
        void onError(Exception e);
    }

    public interface RequestFactory {

        @NonNull
        UrlRequest makeRequest(URL url, Listener listener);
    }
    private static RequestFactory factory = new RequestFactory() {
        @NonNull
        @Override
        public UrlRequest makeRequest(URL url, Listener listener) {
            return new UrlRequest(url, listener);
        }
    };

    private URL url;
    private Listener listener;

    public static UrlRequest makeRequest(URL url, Listener listener) {
        return factory.makeRequest(url, listener);
    }

    public static void setFactory(RequestFactory newFactory) {
        factory = newFactory;
    }

    public UrlRequest(URL url, Listener listener) {
        this.url = url;
        this.listener = listener;
    }

    @Override
    public void run() {
        try {
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            InputStream stream = connection.getInputStream();
            int responseCode = connection.getResponseCode();
            ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
            byte buffer[] = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = stream.read(buffer)) > 0) {
                responseBody.write(buffer, 0, bytesRead);
            }
            listener.onReceivedBody(responseCode, responseBody.toByteArray());
        }
        catch (Exception e) {
            listener.onError(e);
        }
    }
}