Tutorial e exemplos do Android Runnable

Andróide Runnable Tutorial e exemplos.

Nesta classe, vemos a interface Runnable e vemos seus exemplos de utilização.

O que é Runnable?

Em java a interface Runnable é basicamente uma abstração para um comando executável.*

Falamos da classe Thread como uma construção de baixo nível de concorrência para java e andróide.

Bem, outro bloco de construção é a Runnable', uma interface que vem da API Java, e que pretende especificar e encapsular o código que se destina a ser executado por uma instância Java thread' ou qualquer outra classe que lide com esta `Runnable'.

É uma interface e é definida no pacote 'java.lang' e tem um método abstrato chamado run() que temos de implementar.

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

Utilização

A interface "Executável" é utilizada extensivamente para executar código em "Tópicos".
A interface Runnable tem um método abstrato chamado run():

public abstract void run ()

Normalmente, você implementa esse método sempre que sua classe implementa a interface `Runnable'.
O método será então chamado para começar a executar a parte ativa do código da classe.

Digamos que queremos utilizar a Runnable como nosso mecanismo de threading. Bem, primeiro implemente a interface. Em seguida, forneça a implementação para o método run():

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

Com isso, nossa subclasse "Executável" pode agora ser passada para a "Linha" e é executada de forma independente na linha de execução concorrente:

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

No código a seguir, basicamente criamos a subclasse "Executável" para que ela
implementa o método run() e pode ser passado e executado por um fio:

Runnable Interface Subclasses Indiretas

O "Executável" tem muitos deles, por isso listamos apenas os mais usados:

Vamos agora ver alguns exemplos:

Android Runnable Exemplo Passo a Passo

Este é um exemplo de andróide. O Android obviamente utiliza Java e a interface Runnable existe desde a API nível 1.

Podemos utilizar uma Runnable com um Service como a seguir:

public class MyService extends Service implements Runnable{}

Isto nos forçará a implementar o método abstrato run() dentro daquela classe:

 @Override
    public void run() {
    }

E dado que este é um "Serviço", também teremos que substituir outro método abstrato de "Serviço" chamado "onBind()".

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

O "Serviço" é um componente do Android que tem retorno do ciclo de vida. Um deles é o onCreate(), um método que é levantado toda vez que um Service é criado.

Portanto, para nós, toda vez que isso acontece, queremos criar um "tópico" e iniciá-lo:

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

Depois digamos que quero registrar algumas mensagens a cada 1 segundo, acrescente o seguinte código dentro do método run():

        while (true)
        {
            try{

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

Então, como variáveis de instância, adicione o seguinte acima seu método onCreate():

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

Bem, este é um exemplo de utilização de "Executável" com o Android. Se você estiver interessado em ter o "Serviço" realmente executado: então faça o seguinte:

1. Registre o Serviço no Manifesto:

```java

```

Certifique-se de especificar seu &#039;Serviço&#039; em vez de &#039;Meu Serviço&#039;.</code></pre>
<ol start="2">
<li>
<ol start="2">
<li>Inicie o <code>Serviço</code> no <code>MainActivity</code>:</li>
</ol>
</li>
</ol>
<!-- 12 -->
<pre><code>&#x60;&#x60;&#x60;java
Intent i=new Intent(this,MyService.class);
startService(i);
```

E é isso, um exemplo de interface andróide Runnable com serviços.

Note que às vezes as pessoas utilizam a Runnable desta forma:

    @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();

    }

Runnable Amostras rápidas

(a). Como realizar um HTTP GET com HttpurLConnection e `Runnable'.

A "HttpurLConnection" é nossa classe de rede e nos permite realizar nosso pedido "HTTP GET".

Por outro lado, a Runnable é nossa interface que nos permitirá executar nossa solicitação de HTTP GET na linha de fundo.

Assim, você começa implementando a interface "Executável", forçando você a ignorar o método "Executar()`runnable'.

É dentro desse método run() onde executamos nosso 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);
        }
    }
}

Aqui está a classe completa:

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);
        }
    }
}