Ocorreu um erro ao executar meu projeto Android para RssReader.

Código:

URL url = new URL(urlToRssFeed);
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
XMLReader xmlreader = parser.getXMLReader();
RssHandler theRSSHandler = new RssHandler();
xmlreader.setContentHandler(theRSSHandler);
InputSource is = new InputSource(url.openStream());
xmlreader.parse(is);
return theRSSHandler.getFeed();

E mostra o erro abaixo:

android.os.NetworkOnMainThreadException

Como posso corrigir esse problema?

Essa exceção é lançada quando um aplicativo tenta executar uma operação de rede em seu encadeamento principal. Execute seu código em AsyncTask:

class RetrieveFeedTask extends AsyncTask<String, Void, RSSFeed> {

    private Exception exception;

    protected RSSFeed doInBackground(String... urls) {
        try {
            URL url = new URL(urls[0]);
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();
            XMLReader xmlreader = parser.getXMLReader();
            RssHandler theRSSHandler = new RssHandler();
            xmlreader.setContentHandler(theRSSHandler);
            InputSource is = new InputSource(url.openStream());
            xmlreader.parse(is);

            return theRSSHandler.getFeed();
        } catch (Exception e) {
            this.exception = e;

            return null;
        } finally {
            is.close();
        }
    }

    protected void onPostExecute(RSSFeed feed) {
        // TODO: check this.exception
        // TODO: do something with the feed
    }
}

Como executar a tarefa:

No MainActivity.javaarquivo você pode adicionar esta linha dentro do seu oncreate()método

new RetrieveFeedTask().execute(urlToRssFeed);

Não se esqueça de adicionar isso ao AndroidManifest.xmlarquivo:

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

Você quase sempre deve executar operações de rede em um thread ou como uma tarefa assíncrona.

Mas é possível remover essa restrição e você substitui o comportamento padrão, se estiver disposto a aceitar as consequências.

Adicionar:

StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();

StrictMode.setThreadPolicy(policy); 

Em sua classe,

e

ADICIONE essa permissão no arquivo manifest.xml do Android:    

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

Consequências:

Seu aplicativo (em áreas de conexão irregular à Internet) fica sem resposta e trava, o usuário percebe lentidão e precisa fazer uma matança forçada, e você corre o risco de o gerente de atividades matar o aplicativo e dizer ao usuário que o aplicativo parou.

O Android tem algumas boas dicas sobre boas práticas de programação para projetar a capacidade de resposta: http://developer.android.com/reference/android/os/NetworkOnMainThreadException.html

Resolvi esse problema usando um novo Thread.

Thread thread = new Thread(new Runnable() {

    @Override
    public void run() {
        try  {
            //Your code goes here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});

thread.start(); 

A resposta aceita tem algumas desvantagens significativas. Não é aconselhável usar o AsyncTask para redes, a menos que você realmente saiba o que está fazendo. Algumas das desvantagens incluem:

• As AsyncTask criadas como classes internas não estáticas têm uma referência implícita ao objeto Activity, seu contexto e toda a hierarquia View criada por essa atividade. Esta referência impede que a Atividade seja coletada como lixo até que o trabalho em segundo plano do AsyncTask seja concluído. Se a conexão do usuário for lenta e / ou o download for grande, esses vazamentos de memória de curto prazo podem se tornar um problema - por exemplo, se a orientação mudar várias vezes (e você não cancelar as tarefas em execução) ou o usuário sai da atividade.
• O AsyncTask possui características de execução diferentes, dependendo da plataforma em que é executado: antes do nível 4 da API, o AsyncTasks é executado em série em um único encadeamento em segundo plano; do nível 4 da API ao nível 10 da API, as AsyncTasks são executadas em um pool de até 128 threads; a partir do nível 11 da API, o AsyncTask é executado em série em um único encadeamento em segundo plano (a menos que você use o executeOnExecutormétodo sobrecarregado e forneça um executor alternativo). O código que funciona bem quando executado em série no ICS pode ser interrompido quando executado simultaneamente no Gingerbread, digamos se você tiver dependências inadvertidas da ordem de execução.

Se você deseja evitar vazamentos de memória de curto prazo, ter características de execução bem definidas em todas as plataformas e ter uma base para criar um gerenciamento de rede realmente robusto, convém considerar:

1. Usando uma biblioteca que faz um bom trabalho para você - há uma boa comparação de bibliotecas de rede nesta pergunta ou
2. Usando a Serviceou IntentService, talvez com a PendingIntentpara retornar o resultado através do onActivityResultmétodo da atividade .

Abordagem IntentService

Desvantagens:

• Mais código e complexidade do que AsyncTask, embora não tanto quanto você imagina
• Enfileirará solicitações e as executará em um único encadeamento em segundo plano. Você pode controlar isso facilmente, substituindo-o IntentServicepor uma Serviceimplementação equivalente , talvez como esta .
• Hum, eu não consigo pensar em nenhum outro agora

Parte superior:

• Evita o problema de vazamento de memória a curto prazo
• Se a sua atividade reiniciar enquanto as operações da rede estiverem em andamento, ainda poderá receber o resultado do download através do onActivityResultmétodo
• Plataforma melhor que o AsyncTask para criar e reutilizar códigos de rede robustos. Exemplo: se você precisar fazer um upload importante, poderá fazê-lo AsyncTaskem um Activity, mas se o contexto do usuário sair do aplicativo para atender uma ligação, o sistema poderá encerrá-lo antes que o upload seja concluído. É menos provável que mate um aplicativo com um ativo Service.
• Se você usar sua própria versão simultânea IntentService(como a que eu vinculei acima), poderá controlar o nível de simultaneidade via Executor.

Resumo de implementação

Você pode implementar um IntentServicepara executar downloads em um único thread em segundo plano com bastante facilidade.

Etapa 1: Crie um IntentServicepara executar o download. Você pode dizer o que fazer o download via Intentextra e passá-lo PendingIntentpara usar para retornar o resultado para Activity:

import android.app.IntentService;
import android.app.PendingIntent;
import android.content.Intent;
import android.util.Log;

import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;

public class DownloadIntentService extends IntentService {

    private static final String TAG = DownloadIntentService.class.getSimpleName();

    public static final String PENDING_RESULT_EXTRA = "pending_result";
    public static final String URL_EXTRA = "url";
    public static final String RSS_RESULT_EXTRA = "url";

    public static final int RESULT_CODE = 0;
    public static final int INVALID_URL_CODE = 1;
    public static final int ERROR_CODE = 2;

    private IllustrativeRSSParser parser;

    public DownloadIntentService() {
        super(TAG);

        // make one and re-use, in the case where more than one intent is queued
        parser = new IllustrativeRSSParser();
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        PendingIntent reply = intent.getParcelableExtra(PENDING_RESULT_EXTRA);
        InputStream in = null;
        try {
            try {
                URL url = new URL(intent.getStringExtra(URL_EXTRA));
                IllustrativeRSS rss = parser.parse(in = url.openStream());

                Intent result = new Intent();
                result.putExtra(RSS_RESULT_EXTRA, rss);

                reply.send(this, RESULT_CODE, result);
            } catch (MalformedURLException exc) {
                reply.send(INVALID_URL_CODE);
            } catch (Exception exc) {
                // could do better by treating the different sax/xml exceptions individually
                reply.send(ERROR_CODE);
            }
        } catch (PendingIntent.CanceledException exc) {
            Log.i(TAG, "reply cancelled", exc);
        }
    }
}

Etapa 2: registre o serviço no manifesto:

<service
        android:name=".DownloadIntentService"
        android:exported="false"/>

Etapa 3: Invoque o serviço da Atividade, passando um objeto PendingResult que o Serviço usará para retornar o resultado:

PendingIntent pendingResult = createPendingResult(
    RSS_DOWNLOAD_REQUEST_CODE, new Intent(), 0);
Intent intent = new Intent(getApplicationContext(), DownloadIntentService.class);
intent.putExtra(DownloadIntentService.URL_EXTRA, URL);
intent.putExtra(DownloadIntentService.PENDING_RESULT_EXTRA, pendingResult);
startService(intent);

Etapa 4: manipular o resultado em onActivityResult:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == RSS_DOWNLOAD_REQUEST_CODE) {
        switch (resultCode) {
            case DownloadIntentService.INVALID_URL_CODE:
                handleInvalidURL();
                break;
            case DownloadIntentService.ERROR_CODE:
                handleError(data);
                break;
            case DownloadIntentService.RESULT_CODE:
                handleRSS(data);
                break;
        }
        handleRSS(data);
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Um projeto do Github que contém um projeto completo do Android-Studio / Gradle está disponível aqui .

Você não pode executar E / S de rede no thread da interface do usuário no Honeycomb . Tecnicamente, isso é possível nas versões anteriores do Android, mas é uma péssima idéia, pois fará com que o aplicativo pare de responder e pode resultar no sistema operacional que mata o seu aplicativo por se comportar mal. Você precisará executar um processo em segundo plano ou usar o AsyncTask para executar sua transação de rede em um thread em segundo plano.

Há um artigo sobre o Painless Threading no site do desenvolvedor do Android, que é uma boa introdução a isso e fornecerá uma resposta muito melhor do que a fornecida realisticamente aqui.

1. Não use strictMode (apenas no modo de depuração)
2. Não altere a versão do SDK
3. Não use um thread separado

Use Service ou AsyncTask

Veja também a questão Stack Overflow:

android.os.NetworkOnMainThreadException enviando um email do Android

Execute as ações de rede em outro segmento

Por exemplo:

new Thread(new Runnable(){
    @Override
    public void run() {
        // Do network action in this function
    }
}).start();

E adicione isso ao AndroidManifest.xml

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

Você desabilita o modo estrito usando o seguinte código:

if (android.os.Build.VERSION.SDK_INT > 9) {
    StrictMode.ThreadPolicy policy = 
        new StrictMode.ThreadPolicy.Builder().permitAll().build();
    StrictMode.setThreadPolicy(policy);
}

Isso não é recomendado : use a AsyncTaskinterface.

Código completo para ambos os métodos

Operações baseadas em rede não podem ser executadas no thread principal. Você precisa executar todas as tarefas baseadas em rede em um thread filho ou implementar o AsyncTask.

É assim que você executa uma tarefa em um thread filho:

new Thread(new Runnable(){
    @Override
    public void run() {
        try {
            // Your implementation goes here
        } 
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}).start();

Coloque seu código dentro:

new Thread(new Runnable(){
    @Override
    public void run() {
        try {
            // Your implementation
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}).start();

Ou:

class DemoTask extends AsyncTask<Void, Void, Void> {

    protected Void doInBackground(Void... arg0) {
        //Your implementation
    }

    protected void onPostExecute(Void result) {
        // TODO: do something with the feed
    }
}

Isso acontece no Android 3.0 e acima. A partir do Android 3.0 e superior, eles restringiram o uso de operações de rede (funções que acessam a Internet) da execução no thread principal / thread da interface do usuário (o que gera seus métodos de criação e continuação na atividade).

Isso é para incentivar o uso de threads separados para operações de rede. Consulte AsyncTask para obter mais detalhes sobre como executar atividades de rede da maneira certa.

Usar anotações do Android é uma opção. Isso permitirá que você simplesmente execute qualquer método em um thread em segundo plano:

// normal method
private void normal() {
    doSomething(); // do something in background
}

@Background
protected void doSomething() 
    // run your networking code here
}

Observe que, embora ofereça benefícios de simplicidade e legibilidade, tem suas desvantagens.

O erro ocorre devido à execução de operações de execução longa no thread principal. Você pode corrigir facilmente o problema usando AsynTask ou Thread . Você pode fazer o check-out desta biblioteca AsyncHTTPClient para obter um melhor tratamento.

AsyncHttpClient client = new AsyncHttpClient();
client.get("http://www.google.com", new AsyncHttpResponseHandler() {

    @Override
    public void onStart() {
        // Called before a request is started
    }

    @Override
    public void onSuccess(int statusCode, Header[] headers, byte[] response) {
        // Called when response HTTP status is "200 OK"
    }

    @Override
    public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) {
        // Called when response HTTP status is "4XX" (for example, 401, 403, 404)
    }

    @Override
    public void onRetry(int retryNo) {
        // Called when request is retried
    }
});

Você não deve executar nenhuma tarefa demorada no encadeamento principal (encadeamento da UI), como qualquer operação de rede, E / S de arquivo ou operações de banco de dados SQLite. Portanto, para esse tipo de operação, você deve criar um encadeamento de trabalho, mas o problema é que não é possível executar diretamente nenhuma operação relacionada à interface do usuário a partir do encadeamento de trabalho. Para isso, você deve usar Handlere passar o Message.

Para simplificar todas estas coisas, Android fornece várias maneiras, como AsyncTask, AsyncTaskLoader, CursorLoaderou IntentService. Então você pode usar qualquer um deles de acordo com seus requisitos.

A resposta superior do spektom funciona perfeitamente.

Se você estiver escrevendo o AsyncTaskinline e não estendendo como uma classe, além disso, se houver necessidade de obter uma resposta AsyncTask, pode-se usar o get()método como abaixo.

RSSFeed feed = new RetreiveFeedTask().execute(urlToRssFeed).get();

(Do exemplo dele.)

Isso é lançado somente para aplicativos direcionados ao SDK do Honeycomb ou superior. Os aplicativos direcionados para as versões anteriores do SDK podem fazer networking em seus encadeamentos de loop de eventos principais.

O erro é o aviso do SDK!

Para mim foi isso:

<uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="10" />

O dispositivo em que eu estava testando meu aplicativo era 4.1.2, que é o SDK versão 16!

Verifique se a versão de destino é igual à sua Biblioteca de destino do Android. Se você não souber qual é a sua biblioteca de destino, clique com o botão direito do mouse em Projeto -> Caminho da Construção -> Android , e deve ser a que está marcada.

Além disso, como outros já mencionaram, inclua as permissões corretas para acessar a Internet:

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

Use isso em sua atividade

    btnsub.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub

                    //Initialize soap request + add parameters
                    SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME1);

                    //Use this to add parameters
                    request.addProperty("pincode", txtpincode.getText().toString());
                    request.addProperty("bg", bloodgroup.getSelectedItem().toString());

                    //Declare the version of the SOAP request
                    SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);

                    envelope.setOutputSoapObject(request);
                    envelope.dotNet = true;

                    try {
                        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

                        //this is the actual part that will call the webservice
                        androidHttpTransport.call(SOAP_ACTION1, envelope);

                        // Get the SoapResult from the envelope body.
                        SoapObject result = (SoapObject) envelope.getResponse();
                        Log.e("result data", "data" + result);
                        SoapObject root = (SoapObject) result.getProperty(0);
                        // SoapObject s_deals = (SoapObject) root.getProperty(0);
                        // SoapObject s_deals_1 = (SoapObject) s_deals.getProperty(0);
                        //

                        System.out.println("********Count : " + root.getPropertyCount());

                        value = new ArrayList<Detailinfo>();

                        for (int i = 0; i < root.getPropertyCount(); i++) {
                            SoapObject s_deals = (SoapObject) root.getProperty(i);
                            Detailinfo info = new Detailinfo();

                            info.setFirstName(s_deals.getProperty("Firstname").toString());
                            info.setLastName(s_deals.getProperty("Lastname").toString());
                            info.setDOB(s_deals.getProperty("DOB").toString());
                            info.setGender(s_deals.getProperty("Gender").toString());
                            info.setAddress(s_deals.getProperty("Address").toString());
                            info.setCity(s_deals.getProperty("City").toString());
                            info.setState(s_deals.getProperty("State").toString());
                            info.setPinecode(s_deals.getProperty("Pinecode").toString());
                            info.setMobile(s_deals.getProperty("Mobile").toString());
                            info.setEmail(s_deals.getProperty("Email").toString());
                            info.setBloodgroup(s_deals.getProperty("Bloodgroup").toString());
                            info.setAdddate(s_deals.getProperty("Adddate").toString());
                            info.setWaight(s_deals.getProperty("waight").toString());
                            value.add(info);
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Intent intent = new Intent(getApplicationContext(), ComposeMail.class);
                    //intent.putParcelableArrayListExtra("valuesList", value);

                    startActivity(intent);
                }
            }).start();
        }
    });

Apenas para esclarecer algo explicitamente:

O thread principal é basicamente o thread da interface do usuário.

Dizer que você não pode realizar operações de rede no encadeamento principal significa que não pode realizar operações de rede no encadeamento da interface do usuário, o que significa que não é possível realizar operações de rede em um *runOnUiThread(new Runnable() { ... }*bloco dentro de outro encadeamento.

(Eu tive um longo momento de coçar a cabeça tentando descobrir por que estava recebendo esse erro em outro lugar que não o meu thread principal. Foi por isso; esse thread ajudou; e espero que esse comentário ajude outra pessoa.)

Essa exceção ocorre devido a qualquer tarefa pesada executada no encadeamento principal, se essa tarefa em execução demorar muito tempo .

Para evitar isso, podemos lidar com isso usando threads ou executores

Executors.newSingleThreadExecutor().submit(new Runnable() {
    @Override
    public void run() {
        // You can perform your task here.
    }
});

Já existem muitas ótimas respostas para essa pergunta, mas muitas grandes bibliotecas surgiram desde que essas respostas foram postadas. Este é um tipo de guia para iniciantes.

Vou cobrir vários casos de uso para executar operações de rede e uma ou duas soluções para cada uma.

ReST sobre HTTP

Tipicamente Json, pode ser XML ou outra coisa

Acesso completo à API

Digamos que você esteja escrevendo um aplicativo que permita aos usuários acompanhar os preços das ações, taxas de juros e taxas de câmbio. Você encontra uma API Json que se parece com isso:

http://api.example.com/stocks                       //ResponseWrapper<String> object containing a list of Srings with ticker symbols
http://api.example.com/stocks/$symbol               //Stock object
http://api.example.com/stocks/$symbol/prices        //PriceHistory<Stock> object
http://api.example.com/currencies                   //ResponseWrapper<String> object containing a list of currency abbreviation
http://api.example.com/currencies/$currency         //Currency object
http://api.example.com/currencies/$id1/values/$id2  //PriceHistory<Currency> object comparing the prices of the first currency (id1) to the second (id2)

Retrofit from Square

Essa é uma excelente opção para uma API com vários pontos de extremidade e permite declarar os pontos de extremidade do ReST em vez de precisar codificá-los individualmente, como acontece com outras bibliotecas como ion ou Volley. (site: http://square.github.io/retrofit/ )

Como você o usa com a API de finanças?

build.gradle

Adicione estas linhas ao seu buid.gradle no nível do módulo:

implementation 'com.squareup.retrofit2:retrofit:2.3.0' //retrofit library, current as of September 21, 2017
implementation 'com.squareup.retrofit2:converter-gson:2.3.0' //gson serialization and deserialization support for retrofit, version must match retrofit version

FinancesApi.java

public interface FinancesApi {
    @GET("stocks")
    Call<ResponseWrapper<String>> listStocks();
    @GET("stocks/{symbol}")
    Call<Stock> getStock(@Path("symbol")String tickerSymbol);
    @GET("stocks/{symbol}/prices")
    Call<PriceHistory<Stock>> getPriceHistory(@Path("symbol")String tickerSymbol);

    @GET("currencies")
    Call<ResponseWrapper<String>> listCurrencies();
    @GET("currencies/{symbol}")
    Call<Currency> getCurrency(@Path("symbol")String currencySymbol);
    @GET("currencies/{symbol}/values/{compare_symbol}")
    Call<PriceHistory<Currency>> getComparativeHistory(@Path("symbol")String currency, @Path("compare_symbol")String currencyToPriceAgainst);
}

FinancesApiBuilder

public class FinancesApiBuilder {
    public static FinancesApi build(String baseUrl){
        return new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build()
                    .create(FinancesApi.class);
    }
}

Fragmento de fragmento

FinancesApi api = FinancesApiBuilder.build("http://api.example.com/"); //trailing '/' required for predictable behavior
api.getStock("INTC").enqueue(new Callback<Stock>(){
    @Override
    public void onResponse(Call<Stock> stockCall, Response<Stock> stockResponse){
        Stock stock = stockCall.body();
        //do something with the stock
    }
    @Override
    public void onResponse(Call<Stock> stockCall, Throwable t){
        //something bad happened
    }
}

Se sua API exigir que uma chave de API ou outro cabeçalho como um token de usuário etc. seja enviado, o Retrofit facilita isso (consulte esta resposta incrível para obter detalhes: https://stackoverflow.com/a/42899766/1024412 ).

Acesso único à API do ReST

Digamos que você esteja criando um aplicativo "clima ameno" que pesquise a localização do GPS do usuário e verifique a temperatura atual nessa área e informe o clima. Esse tipo de aplicativo não precisa declarar pontos de extremidade da API; ele só precisa acessar um ponto de extremidade da API.

Íon

Esta é uma ótima biblioteca para esse tipo de acesso.

Leia a excelente resposta de msysmilu ( https://stackoverflow.com/a/28559884/1024412 )

Carregar imagens via HTTP

Vôlei

O Volley também pode ser usado para APIs ReST, mas devido à configuração mais complicada necessária, eu prefiro usar o Retrofit from Square como acima ( http://square.github.io/retrofit/ )

Digamos que você esteja criando um aplicativo de rede social e deseje carregar fotos de perfil de amigos.

build.gradle

Adicione esta linha ao seu nível de módulo buid.gradle:

implementation 'com.android.volley:volley:1.0.0'

ImageFetch.java

O Volley requer mais configuração que o Retrofit. Você precisará criar uma classe como esta para configurar um RequestQueue, um ImageLoader e um ImageCache, mas não é tão ruim assim:

public class ImageFetch {
    private static ImageLoader imageLoader = null;
    private static RequestQueue imageQueue = null;

    public static ImageLoader getImageLoader(Context ctx){
        if(imageLoader == null){
            if(imageQueue == null){
                imageQueue = Volley.newRequestQueue(ctx.getApplicationContext());
            }
            imageLoader = new ImageLoader(imageQueue, new ImageLoader.ImageCache() {
                Map<String, Bitmap> cache = new HashMap<String, Bitmap>();
                @Override
                public Bitmap getBitmap(String url) {
                    return cache.get(url);
                }
                @Override
                public void putBitmap(String url, Bitmap bitmap) {
                    cache.put(url, bitmap);
                }
            });
        }
        return imageLoader;
    }
}

user_view_dialog.xml

Adicione o seguinte ao arquivo xml de layout para adicionar uma imagem:

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/profile_picture"
    android:layout_width="32dp"
    android:layout_height="32dp"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    app:srcCompat="@android:drawable/spinner_background"/>

UserViewDialog.java

Adicione o seguinte código ao método onCreate (Fragment, Activity) ou ao construtor (Dialog):

NetworkImageView profilePicture = view.findViewById(R.id.profile_picture);
profilePicture.setImageUrl("http://example.com/users/images/profile.jpg", ImageFetch.getImageLoader(getContext());

Picasso

Outra excelente biblioteca da Square. Consulte o site para alguns ótimos exemplos: http://square.github.io/picasso/

Em palavras simples,

NÃO TRABALHE EM REDE NA LINHA DA UI

Por exemplo, se você fizer uma solicitação HTTP, essa é uma ação de rede.

Solução:

1. Você precisa criar um novo thread
2. Ou use a classe AsyncTask

Caminho:

Coloque todos os seus trabalhos dentro

1. run() método de nova discussão
2. Ou doInBackground() método da classe AsyncTask.

Mas:

Quando você obtém algo da resposta de rede e deseja mostrá-lo em sua exibição (como exibir mensagem de resposta no TextView), é necessário retornar ao thread da interface do usuário .

Se você não fizer isso, você receberá ViewRootImpl$CalledFromWrongThreadException.

Como?

1. Ao usar o AsyncTask, atualize a exibição do onPostExecute()método
2. Ou chame o runOnUiThread()método e atualize a exibição dentro do run()método.

Você pode mover uma parte do seu código para outro thread para descarregar main threade evitar ANR , NetworkOnMainThreadException , IllegalStateException (por exemplo, não é possível acessar o banco de dados no thread principal, pois pode bloquear a interface do usuário por um longo período de tempo).

Existem algumas abordagens que você deve escolher depende da situação

Thread Java ou Android HandlerThread

Os encadeamentos Java são usados ​​apenas uma vez e morrem após a execução de seu método de execução.

HandlerThread é uma classe útil para iniciar um novo thread que possui um looper.

AsyncTask

O AsyncTask foi projetado para ser uma classe auxiliar em torno do Thread and Handler e não constitui uma estrutura de encadeamento genérica. Idealmente, as AsyncTasks devem ser usadas para operações curtas (no máximo, alguns segundos). Se você precisar manter os threads em execução por longos períodos, é altamente recomendável usar as várias APIs fornecidas pelo pacote java.util.concurrent, como Executor , ThreadPoolExecutor e FutureTask .

Implementação do conjunto de encadeamentos ThreadPoolExecutor , ScheduledThreadPoolExecutor ...

Classe ThreadPoolExecutor que implementa ExecutorService, que fornece controle fino sobre o conjunto de encadeamentos (por exemplo, tamanho do conjunto principal, tamanho máximo do conjunto, tempo de vida útil etc.)

ScheduledThreadPoolExecutor - uma classe que estende o ThreadPoolExecutor. Ele pode agendar tarefas após um determinado atraso ou periodicamente.

FutureTask

FutureTask executa processamento assíncrono; no entanto, se o resultado ainda não estiver pronto ou o processamento não estiver concluído, a chamada de get () bloqueará o encadeamento.

AsyncTaskLoaders

AsyncTaskLoaders, pois resolvem muitos problemas inerentes ao AsyncTask

IntentService

Esta é a opção padrão para o processamento de longa execução no Android; um bom exemplo seria o upload ou o download de arquivos grandes. O upload e o download podem continuar mesmo se o usuário sair do aplicativo e você certamente não desejar impedir o usuário de usá-lo enquanto essas tarefas estiverem em andamento.

JobScheduler

Efetivamente, você precisa criar um Serviço e criar um trabalho usando JobInfo.Builder que especifique seus critérios para quando executar o serviço.

RxJava

Biblioteca para compor programas assíncronos e baseados em eventos usando sequências observáveis.

Corotinas (Kotlin)

O principal é que ele faz com que o código assíncrono se pareça com o síncrono

Leia mais aqui , aqui , aqui , aqui

Embora acima haja um enorme pool de soluções, ninguém mencionou com.koushikdutta.ion: https://github.com/koush/ion

Também é assíncrono e muito simples de usar:

Ion.with(context)
.load("http://example.com/thing.json")
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});

As soluções novas Threade AsyncTask já foram explicadas.

AsyncTaskidealmente deve ser usado para operações curtas. NormalThread não é preferível para Android.

Dê uma olhada na solução alternativa usando HandlerThread e Handler

HandlerThread

Classe útil para iniciar um novo thread que possui um looper. O looper pode então ser usado para criar classes de manipuladores. Observe que start()ainda deve ser chamado.

Manipulador:

Um manipulador permite enviar e processar objetos Message e Runnable associados ao MessageQueue de um thread. Cada instância do manipulador está associada a um único encadeamento e à fila de mensagens desse encadeamento. Quando você cria um novo manipulador, ele é vinculado à fila de encadeamentos / mensagens do encadeamento que o está criando - a partir desse momento, ele envia mensagens e executáveis ​​para essa fila de mensagens e os executa à medida que saem da mensagem fila.

Solução:

1. Crio HandlerThread

2. Ligue start()paraHandlerThread

3. Crie Handlerobtendo LooperdeHanlerThread

4. Incorpore o código relacionado à operação de rede no Runnableobjeto

5. Enviar Runnabletarefa paraHandler

Exemplo de trecho de código, que endereço NetworkOnMainThreadException

HandlerThread handlerThread = new HandlerThread("URLConnection");
handlerThread.start();
handler mainHandler = new Handler(handlerThread.getLooper());

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Log.d("Ravi", "Before IO call");
            URL page = new URL("http://www.google.com");
            StringBuffer text = new StringBuffer();
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader in = new InputStreamReader((InputStream) conn.getContent());
            BufferedReader buff = new BufferedReader(in);
            String line;
            while ( (line =  buff.readLine()) != null) {
                text.append(line + "\n");
            }
            Log.d("Ravi", "After IO call");
            Log.d("Ravi",text.toString());

        }catch( Exception err){
            err.printStackTrace();
        }
    }
};
mainHandler.post(myRunnable);

Prós de usar esta abordagem:

1. Criar novo Thread/AsyncTaskpara cada operação de rede é caro. O Thread/AsyncTaskserá destruído e recriado para as próximas operações de rede. Mas com Handlere com a HandlerThreadabordagem, você pode enviar muitas operações de rede (como tarefas executáveis) para uma única HandlerThreadusando Handler.

RxAndroidé outra alternativa melhor para esse problema e evita aborrecimentos na criação de threads e na publicação de resultados no thread da interface do usuário do Android. Nós apenas precisamos especificar threads nos quais as tarefas precisam ser executadas e tudo é tratado internamente.

Observable<List<String>> musicShowsObservable = Observable.fromCallable(new Callable<List<String>>() { 

  @Override 
  public List<String> call() { 
    return mRestClient.getFavoriteMusicShows(); 
  }
});

mMusicShowSubscription = musicShowsObservable
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<List<String>>() {

    @Override 
    public void onCompleted() { }

    @Override 
    public void onError(Throwable e) { }

    @Override 
    public void onNext(List<String> musicShows){
        listMusicShows(musicShows);
    }
});

1. , Especificando (Schedulers.io()), RxAndroid será executado getFavoriteMusicShows() em um segmento diferente.

2. Ao usar AndroidSchedulers.mainThread(), queremos observar este Observável no thread da interface do usuário, ou seja, queremos que nosso onNext()retorno de chamada seja chamado no thread da interface do usuário

O thread principal é o thread da interface do usuário e você não pode executar uma operação no thread principal que possa bloquear a interação do usuário. Você pode resolver isso de duas maneiras:

Forçar a executar a tarefa no thread principal como este

StrictMode.ThreadPolicy threadPolicy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(threadPolicy);

Ou crie um manipulador simples e atualize o segmento principal, se desejar.

Runnable runnable;
Handler newHandler;

newHandler = new Handler();
runnable = new Runnable() {
    @Override
    public void run() {
         try {
            //update UI
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
};
newHandler.post(runnable);

E para parar o thread, use:

newHandler.removeCallbacks(runnable);

Para obter mais informações, consulte: Rosqueamento indolor

Isso funciona. Apenas simplificou a resposta do Dr. Luiji.

new Thread() {
    @Override
    public void run() {
        try {
            //Your code goes here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}.start();

No Android, as operações de rede não podem ser executadas no thread principal. Você pode usar o Thread, AsyncTask (tarefas de execução curta), Serviço (tarefas de execução longa) para executar operações de rede.

O acesso a recursos de rede a partir do thread principal (UI) causa essa exceção. Use um thread separado ou o AsyncTask para acessar um recurso de rede para evitar esse problema.