Ufyukyu

Question

I got an error while running my Android project for RssReader.

Code:

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

And it shows the below error:

android.os.NetworkOnMainThreadException

How can I fix this issue?

Read this blog post on the NetworkOnMainThreadException for more information. It explains why this occurs on Android 3.0 and above. — Aug 7 '12 at 12:38
To be on rite track first read about the Network Requests in android then i would recommend to study "Volley". — Jan 23 '14 at 6:39
There are many alternative libraries that solve this issue. Many are listed at the bottom of this page. If you got more, we take them :) — Feb 11 '14 at 22:55
You need to run internet activities on a thread separate from main (UI) thread — Oct 30 '14 at 20:44

Vova Stelmashchuk 322111 · Accepted Answer · 2017-11-28 11:57:55Z

2344

This exception is thrown when an application attempts to perform a networking operation on its main thread. Run your code in 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

    }

}

How to execute the task:

In MainActivity.java file you can add this line within your oncreate() method

new RetrieveFeedTask().execute(urlToRssFeed);

Don't forget to add this to AndroidManifest.xml file:

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

edited Nov 28 '17 at 11:57

Vova Stelmashchuk

322111

answered Jun 14 '11 at 12:15

spektom

28.9k24274

31

I think it is worth noting here that the code snippet above is supposed to be a subclass (inner class), preferably private. That way when the AsyncTask finishes, you can still manipulate the innards of your class.

– dyslexicanaboko
Jul 22 '12 at 5:57

3

Actually i did the Same thing as u mentioned above but m facing this error java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()

– Dhruv Tyagi
Aug 30 '16 at 11:08

44

This is exactly the wrong answer. I come across this all the time in peoples code, and its annoying to have to fix it all the time. AsyncTask should not be used for network activity, because it's tied to the activity, but not the activity lifecycle. Rotating the device with this task is running will cause an exception and crash your app. Use an IntentService that drops data in the sqlite database instead.

– Brill Pappin
Sep 9 '16 at 19:08

1

Caution, AsyncTask is often used for per activity network operations when it should not be. its lifecycle is not in sync with the activity. For fetching data, you should use an IntentService and the database behind the view.

– Brill Pappin
Oct 5 '16 at 21:24

1

@BrillPappin I am glad that i explored the comments, otherwise i would have gone with Async Task thanks.

– Shivam Pokhriyal
Sep 5 '18 at 5:26

|
show 11 more comments

EpicPandaForce 48k14127252 · Accepted Answer · 2018-02-11 14:18:49Z

595

You should almost always run network operations on a thread or as an asynchronous task.

But it is possible to remove this restriction and you override the default behavior, if you are willing to accept the consequences.

Add:

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



StrictMode.setThreadPolicy(policy);

In your class,

and

ADD this permission in android manifest.xml file:

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

Consequences:

Your app will (in areas of spotty internet connection) become unresponsive and lock up, the user perceives slowness and has to do a force kill, and you risk the activity manager killing your app and telling the user that the app has stopped.

Android has some good tips on good programming practices to design for responsiveness:
http://developer.android.com/reference/android/os/NetworkOnMainThreadException.html

edited Feb 11 '18 at 14:18

EpicPandaForce

48k14127252

answered Feb 15 '12 at 6:59

user1169115

7,159182

432

This is a very bad idea. the solution is to avoid network IO on main thread (as the accepted answer shows).

– MByD
May 14 '12 at 14:10

66

With this you only hide your real problem.

– Alex
Jun 18 '12 at 6:44

24

@TwistedUmbrella The AsyncTask does not add a page of code, it adds 6 lines (class declaration, override annotation, doInBackground declaration, 2 closing brackets and a call to execute()). On the other hand, even a single fetch from a site as you mention brings a significant lag in the UI responsiveness. Don't be lazy.

– Zoltán
Sep 4 '12 at 9:39

50

@TwistedUmbrella Don't be silly. That is how bad applications are made. Whether it is downloading a text file or an image gallery, you should follow best practices. And running network IO on main thread is not a best practice.

– States
Nov 1 '12 at 1:23

79

Upvoted. This answer is correct, and for the many programmers who are neither naive nor stupid, but who simply require a SYNCHRONOUS (i.e.: this must block the app) call, this is exactly what's needed. I'm more than happy that Android throws the exception by default (IMHO it's a very "helpful" thing to do!) - but I'm equally happy to say "thanks, but - this is actually what I intended" and to override it.

– Adam
May 1 '13 at 6:48

|
show 42 more comments

V-rund Puro-hit 3,96082044 · Accepted Answer · 2016-10-05 09:42:24Z

379

I solved this problem using a new Thread.

Thread thread = new Thread(new Runnable() {



    @Override

    public void run() {

        try  {

            //Your code goes here

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

});



thread.start();

edited Oct 5 '16 at 9:42

V-rund Puro-hit

3,96082044

answered Jan 21 '13 at 16:31

Dr.Luiji

4,64511111

6

Instead of creating a new thread each time you want to perform a network operation, you could use a single thread executor service too.

– Alex Lockwood
Jan 27 '13 at 18:06

56

Simple but dangerous. The anonymous Runnable has an implicit reference to the enclosing class (e.g. your Activity or Fragment), preventing it from being garbage collected until the thread completes. You should at least set the priority to Process.BACKGROUND, else this thread will run at the same priority as the main/ui thread, contending with lifecycle methods and ui frame rates (watch out for warnings in log from the choreographer).

– Stevie
Jun 19 '14 at 12:39

@Stevie how to set the priority? neither runnble nor the executorService have such a setter method

– J. K.
May 31 '15 at 13:26

1

@J.K. Supply your ExecutorService with a custom ThreadFactory and call Thread.setPriority on the thread before returning it.

– Stevie
Jun 1 '15 at 19:14

Setting priority for something that is intended to do a network call (which will block) seems overkill.

– john16384
Jan 27 '16 at 13:09

|
show 2 more comments

Peter Mortensen 13.5k1984111 · Accepted Answer · 2014-02-09 16:25:22Z

You cannot perform network I/O on the UI thread on Honeycomb. Technically, it is possible on earlier versions of Android, but it is a really bad idea as it will cause your app to stop responding, and can result in the OS killing your app for being badly behaved. You'll need to run a background process or use AsyncTask to perform your network transaction on a background thread.

There is an article about Painless Threading on the Android developer site which is a good introduction to this, and it will provide you with a much better depth of an answer than can be realistically provided here.

Community♦ 11 · Accepted Answer · 2017-05-23 12:34:44Z

The accepted answer has some significant down-sides. It is not advisable to use AsyncTask for networking unless you really know what you are doing. Some of the down-sides include:

AsyncTask's created as non-static inner classes have an implicit reference to the enclosing Activity object, its context, and the entire View hierarchy created by that activity. This reference prevents the Activity from being garbage collected until the AsyncTask's background work completes. If the user's connection is slow, and/or the download is large, these short-term memory leaks can become a problem - for example if the orientation changes several times (and you don't cancel the executing tasks), or the user navigates away from the Activity.

AsyncTask has different execution characteristics depending on the platform it executes on: prior to API level 4 AsyncTasks execute serially on a single background thread; from API level 4 through API level 10, AsyncTasks execute on a pool of up to 128 threads; from API level 11 onwards AsyncTask executes serially on a single background thread (unless you use the overloaded executeOnExecutor method and supply an alternative executor). Code that works fine when run serially on ICS may break when executed concurrently on Gingerbread, say, if you have inadvertent order-of-execution dependencies.

If you want to avoid short-term memory leaks, have well defined execution characteristics across all platforms, and have a base to build really robust network handling, you might want to consider:

Using a library that does a nice job of this for you - there's a nice comparison of networking libs in this question, or

Using a Service or IntentService instead, perhaps with a PendingIntent to return the result via the Activity's onActivityResult method.

IntentService approach

Down-sides:

More code and complexity than AsyncTask, though not as much as you might think

Will queue requests and run them on a single background thread. You can easily control this by replacing IntentService with an equivalent Service implementation, perhaps like this one.

Um, I can't think of any others right now actually

Up-sides:

Avoids the short-term memory leak problem

If your activity restarts while network operations are in-flight it can still receive the result of the download via its onActivityResult method

Better platform than AsyncTask to build and re-use robust networking code. Example: if you need to do an important upload, you could do it from AsyncTask in an Activity, but if the user context-switches out of the app to take a phone-call, the system may kill the app before the upload completes. It is less likely to kill an application with an active Service.

If you use your own concurrent version of IntentService (like the one I linked above) you can control the level of concurrency via the Executor.

Implementation summary

You can implement an IntentService to perform downloads on a single background thread quite easily.

Step 1: Create an IntentService to perform the download. You can tell it what to download via Intent extra's, and pass it a PendingIntent to use to return the result to the 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);

        }

    }

}

Step 2: Register the service in the manifest:

<service

        android:name=".DownloadIntentService"

        android:exported="false"/>

Step 3: Invoke the service from the Activity, passing a PendingResult object which the Service will use to return the result:

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

Step 4: Handle the result in 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);

}

A github project containing a complete working Android-Studio/gradle project is available here.

IntentService is the correct way to do this, not uprooting because AsyncTask is exactly the way not to do it. — Sep 10 '16 at 14:59
@BrillPappin I almost entirely agree and have re-worded to emphasize the drawbacks of AsyncTask. (I still think there are a very small number of cases where - if you really know what you are doing - it might be OK to use AsyncTask, but the accepted answer doesn't point out any drawbacks and is way too popular for the good of Android). — Mar 13 '17 at 12:56
Do you actually need IllustrativeRSS? What if you're not working with RSS stuff? — Apr 14 '18 at 19:13

Community♦ 11 · Accepted Answer · 2017-05-23 12:26:38Z

66

Do not use strictMode (only in debug mode)

Do not change SDK version

Do not use a separate thread

Use Service or AsyncTask

ReST over HTTP

Typically Json, can be XML or something else

Full API Access

Let's say you are writing an app that lets users track stock prices, interest rates and currecy exchange rates. You find an Json API that looks something like this:

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

This is an excellent choice for an API with multiple endpoints and allows you to declare the ReST endpoints instead of having to code them individually as with other libraries like ion or Volley. (website: http://square.github.io/retrofit/)

How do you use it with the finances API?

build.gradle

Add these lines to your Module level buid.gradle:

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

    }

}

FinancesFragment snippet

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

    }

}

If your API requires an API Key or other header like a user token, etc. to be sent, Retrofit makes this easy (see this awesome answer for details: https://stackoverflow.com/a/42899766/1024412).

One off ReST API access

Let's say you're building a "mood weather" app that looks up the users GPS location and checks the current temperature in that area and tells them the mood. This type of app doesn't need to declare API endpoints; it just needs to be able to access one API endpoint.

Ion

This is a great library for this type of access.

Please read msysmilu's great answer (https://stackoverflow.com/a/28559884/1024412)

Load images via HTTP

Volley

Volley can also be used for ReST APIs, but due to the more complicated setup required I prefer to use Retrofit from Square as above (http://square.github.io/retrofit/)

Let's say you are building a social networking app and want to load profile pictures of friends.

build.gradle

Add this line to your Module level buid.gradle:

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

ImageFetch.java

Volley requires more setup than Retrofit. You will need to create a class like this to setup a RequestQueue, an ImageLoader and an ImageCache, but it's not too bad:

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

Add the following to your layout xml file to add an image:

<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

Add the following code to the onCreate method (Fragment, Activity) or the constructor (Dialog):

NetworkImageView profilePicture = view.findViewById(R.id.profile_picture);

profilePicture.setImageUrl("http://example.com/users/images/profile.jpg", ImageFetch.getImageLoader(getContext());

Picasso

Another excellent library from Square. Please see the site for some great examples: http://square.github.io/picasso/

this should be the better answer than the original one as it simplifies the implementation of networking on android in the present world 2017, and most of the real world application uses very good libraries like these. — Nov 28 '17 at 11:46

msysmilumsysmilu 1,6101617 · Accepted Answer · 2015-02-17 10:31:31Z

Although above there is a huge solution pool, no one mentioned com.koushikdutta.ion: https://github.com/koush/ion

It's also asynchronous and very simple to use:

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

    }

});

score 8 · Accepted Answer · 2017-11-05 04:41:03Z

New Thread and AsyncTask solutions have been explained already.

AsyncTask should ideally be used for short operations. Normal Thread is not preferable for Android.

Have a look at alternate solution using HandlerThread and Handler

HandlerThread

Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.

Handler:

A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thread and that thread's message queue. When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it -- from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

Solution:

Create HandlerThread

Call start() on HandlerThread

Create Handler by getting Looper from HanlerThread

Embed your Network operation related code in Runnable object

Submit Runnable task to Handler

Sample code snippet, which address 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);

Pros of using this approach:

Creating new Thread/AsyncTask for each network operation is expensive. The Thread/AsyncTask will be destroyed and re-created for next Network operations. But with Handler and HandlerThread approach, you can submit many network operations (as Runnable tasks) to single HandlerThread by using Handler.

KacyKacy 1,50022032 · Accepted Answer · 2015-02-13 23:10:17Z

This works. Just made Dr.Luiji's answer a little simpler.

new Thread() {

    @Override

    public void run() {

        try {

            //Your code goes here

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}.start();

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:32:51Z

7

On Android, network operations cannot be run on the main thread. You can use Thread, AsyncTask (short-running tasks), Service (long-running tasks) to do network operations.

edited Jun 25 '16 at 9:32

Peter Mortensen

13.5k1984111

answered Jun 25 '15 at 7:42

Ponsuyambu Velladurai

1,05411331

add a comment |

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:35:31Z

7

Accessing network resources from the main (UI) thread cause this exception. Use a separate thread or AsyncTask for accessing a network resource to avoid this problem.

edited Jun 25 '16 at 9:35

Peter Mortensen

13.5k1984111

answered Aug 13 '15 at 8:26

RevanthKrishnaKumar V.

1,48411530

add a comment |

Ravindra babu 29.4k5157135 · Accepted Answer · 2017-10-10 07:52:47Z

RxAndroid is another better alternative to this problem and it saves us from hassles of creating threads and then posting results on Android UI thread.
We just need to specify threads on which tasks need to be executed and everything is handled internally.

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

    }

});

By specifiying (Schedulers.io()),RxAndroid will run getFavoriteMusicShows() on a different thread.

By using AndroidSchedulers.mainThread() we want to observe this Observable on the UI thread, i.e. we want our onNext() callback to be called on the UI thread

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:39:03Z

You are not allowed to implement network operations on the UI thread on Android. You will have to use AsyncTask class to perform network related operations like sending API request, downloading image from a URL, etc. and using callback methods of AsyncTask, you can get you result in onPostExecute menthod and you will be in the UI thread and you can populate UI with data from web service or something like that.

Example: Suppose you want to download image from an URL: https://www.samplewebsite.com/sampleimage.jpg

Solution using AsyncTask:
are respectively.

    public class MyDownloader extends AsyncTask<String,Void,Bitmap>

    {

        @Override

        protected void onPreExecute() {

            // Show progress dialog

            super.onPreExecute();

        }



        @Override

        protected void onPostExecute(Bitmap bitmap) {

            //Populate Ui

            super.onPostExecute(bitmap);

        }



        @Override

        protected Bitmap doInBackground(String... params) {

            // Open URL connection read bitmaps and return form here

            return result;

        }



        @Override

        protected void onProgressUpdate(Void... values) {

            // Show progress update

            super.onProgressUpdate(values);

        }





    }

}

Note: Do not forget to add the Internet permission in the Android manifest file. It will work like a charm. :)

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:48:34Z

There is another very convenient way for tackling this issue - use rxJava's concurrency capabilities. You can execute any task in background and post results to main thread in a very convenient way, so these results will be handed to processing chain.

The first verified answer advice is to use AsynTask. Yes, this is a solution, but it is obsolete nowadays, because there are new tools around.

String getUrl() {

    return "SomeUrl";

}



private Object makeCallParseResponse(String url) {

    return null;

    //

}



private void processResponse(Object o) {



}

The getUrl method provides the URL address, and it will be executed on the main thread.

makeCallParseResponse(..) - does actual work

processResponse(..) - will handle result on main thread.

The code for asynchronous execution will look like:

rx.Observable.defer(new Func0<rx.Observable<String>>() {

    @Override

    public rx.Observable<String> call() {

        return rx.Observable.just(getUrl());

    }

})

    .subscribeOn(Schedulers.io())

    .observeOn(Schedulers.io())

    .map(new Func1<String, Object>() {

        @Override

        public Object call(final String s) {

            return makeCallParseResponse(s);

        }

    })

    .observeOn(AndroidSchedulers.mainThread())

    .subscribe(new Action1<Object>() {

        @Override

        public void call(Object o) {

             processResponse(o);

        }

    },

    new Action1<Throwable>() {

        @Override

        public void call(Throwable throwable) {

            // Process error here, it will be posted on

            // the main thread

        }

    });

Compared to AsyncTask, this method allow to switch schedulers an arbitrary number of times (say, fetch data on one scheduler and process those data on another (say, Scheduler.computation()). You can also define you own schedulers.

In order to use this library, include following lines into you build.gradle file:

   compile 'io.reactivex:rxjava:1.1.5'

   compile 'io.reactivex:rxandroid:1.2.0'

The last dependency includes support for the .mainThread() scheduler.

There is an excellent ebook for rx-java.

quite an extensive approach it would to be schedule by our own and i don't know why we should if it is already being an option on Android side? — Sep 15 '16 at 14:10

Vova Stelmashchuk 322111 · Accepted Answer · 2017-11-28 11:57:55Z

2344

This exception is thrown when an application attempts to perform a networking operation on its main thread. Run your code in 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

    }

}

How to execute the task:

In MainActivity.java file you can add this line within your oncreate() method

new RetrieveFeedTask().execute(urlToRssFeed);

Don't forget to add this to AndroidManifest.xml file:

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

edited Nov 28 '17 at 11:57

Vova Stelmashchuk

322111

answered Jun 14 '11 at 12:15

spektom

28.9k24274

31

I think it is worth noting here that the code snippet above is supposed to be a subclass (inner class), preferably private. That way when the AsyncTask finishes, you can still manipulate the innards of your class.

– dyslexicanaboko
Jul 22 '12 at 5:57

3

Actually i did the Same thing as u mentioned above but m facing this error java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()

– Dhruv Tyagi
Aug 30 '16 at 11:08

44

This is exactly the wrong answer. I come across this all the time in peoples code, and its annoying to have to fix it all the time. AsyncTask should not be used for network activity, because it's tied to the activity, but not the activity lifecycle. Rotating the device with this task is running will cause an exception and crash your app. Use an IntentService that drops data in the sqlite database instead.

– Brill Pappin
Sep 9 '16 at 19:08

1

Caution, AsyncTask is often used for per activity network operations when it should not be. its lifecycle is not in sync with the activity. For fetching data, you should use an IntentService and the database behind the view.

– Brill Pappin
Oct 5 '16 at 21:24

1

@BrillPappin I am glad that i explored the comments, otherwise i would have gone with Async Task thanks.

– Shivam Pokhriyal
Sep 5 '18 at 5:26

|
show 11 more comments

EpicPandaForce 48k14127252 · Accepted Answer · 2018-02-11 14:18:49Z

595

You should almost always run network operations on a thread or as an asynchronous task.

But it is possible to remove this restriction and you override the default behavior, if you are willing to accept the consequences.

Add:

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



StrictMode.setThreadPolicy(policy);

In your class,

and

ADD this permission in android manifest.xml file:

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

Consequences:

Your app will (in areas of spotty internet connection) become unresponsive and lock up, the user perceives slowness and has to do a force kill, and you risk the activity manager killing your app and telling the user that the app has stopped.

Android has some good tips on good programming practices to design for responsiveness:
http://developer.android.com/reference/android/os/NetworkOnMainThreadException.html

edited Feb 11 '18 at 14:18

EpicPandaForce

48k14127252

answered Feb 15 '12 at 6:59

user1169115

7,159182

432

This is a very bad idea. the solution is to avoid network IO on main thread (as the accepted answer shows).

– MByD
May 14 '12 at 14:10

66

With this you only hide your real problem.

– Alex
Jun 18 '12 at 6:44

24

@TwistedUmbrella The AsyncTask does not add a page of code, it adds 6 lines (class declaration, override annotation, doInBackground declaration, 2 closing brackets and a call to execute()). On the other hand, even a single fetch from a site as you mention brings a significant lag in the UI responsiveness. Don't be lazy.

– Zoltán
Sep 4 '12 at 9:39

50

@TwistedUmbrella Don't be silly. That is how bad applications are made. Whether it is downloading a text file or an image gallery, you should follow best practices. And running network IO on main thread is not a best practice.

– States
Nov 1 '12 at 1:23

79

Upvoted. This answer is correct, and for the many programmers who are neither naive nor stupid, but who simply require a SYNCHRONOUS (i.e.: this must block the app) call, this is exactly what's needed. I'm more than happy that Android throws the exception by default (IMHO it's a very "helpful" thing to do!) - but I'm equally happy to say "thanks, but - this is actually what I intended" and to override it.

– Adam
May 1 '13 at 6:48

|
show 42 more comments

V-rund Puro-hit 3,96082044 · Accepted Answer · 2016-10-05 09:42:24Z

379

I solved this problem using a new Thread.

Thread thread = new Thread(new Runnable() {



    @Override

    public void run() {

        try  {

            //Your code goes here

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

});



thread.start();

edited Oct 5 '16 at 9:42

V-rund Puro-hit

3,96082044

answered Jan 21 '13 at 16:31

Dr.Luiji

4,64511111

6

Instead of creating a new thread each time you want to perform a network operation, you could use a single thread executor service too.

– Alex Lockwood
Jan 27 '13 at 18:06

56

Simple but dangerous. The anonymous Runnable has an implicit reference to the enclosing class (e.g. your Activity or Fragment), preventing it from being garbage collected until the thread completes. You should at least set the priority to Process.BACKGROUND, else this thread will run at the same priority as the main/ui thread, contending with lifecycle methods and ui frame rates (watch out for warnings in log from the choreographer).

– Stevie
Jun 19 '14 at 12:39

@Stevie how to set the priority? neither runnble nor the executorService have such a setter method

– J. K.
May 31 '15 at 13:26

1

@J.K. Supply your ExecutorService with a custom ThreadFactory and call Thread.setPriority on the thread before returning it.

– Stevie
Jun 1 '15 at 19:14

Setting priority for something that is intended to do a network call (which will block) seems overkill.

– john16384
Jan 27 '16 at 13:09

|
show 2 more comments

Peter Mortensen 13.5k1984111 · Accepted Answer · 2014-02-09 16:25:22Z

You cannot perform network I/O on the UI thread on Honeycomb. Technically, it is possible on earlier versions of Android, but it is a really bad idea as it will cause your app to stop responding, and can result in the OS killing your app for being badly behaved. You'll need to run a background process or use AsyncTask to perform your network transaction on a background thread.

There is an article about Painless Threading on the Android developer site which is a good introduction to this, and it will provide you with a much better depth of an answer than can be realistically provided here.

Community♦ 11 · Accepted Answer · 2017-05-23 12:34:44Z

The accepted answer has some significant down-sides. It is not advisable to use AsyncTask for networking unless you really know what you are doing. Some of the down-sides include:

AsyncTask's created as non-static inner classes have an implicit reference to the enclosing Activity object, its context, and the entire View hierarchy created by that activity. This reference prevents the Activity from being garbage collected until the AsyncTask's background work completes. If the user's connection is slow, and/or the download is large, these short-term memory leaks can become a problem - for example if the orientation changes several times (and you don't cancel the executing tasks), or the user navigates away from the Activity.

AsyncTask has different execution characteristics depending on the platform it executes on: prior to API level 4 AsyncTasks execute serially on a single background thread; from API level 4 through API level 10, AsyncTasks execute on a pool of up to 128 threads; from API level 11 onwards AsyncTask executes serially on a single background thread (unless you use the overloaded executeOnExecutor method and supply an alternative executor). Code that works fine when run serially on ICS may break when executed concurrently on Gingerbread, say, if you have inadvertent order-of-execution dependencies.

If you want to avoid short-term memory leaks, have well defined execution characteristics across all platforms, and have a base to build really robust network handling, you might want to consider:

Using a library that does a nice job of this for you - there's a nice comparison of networking libs in this question, or

Using a Service or IntentService instead, perhaps with a PendingIntent to return the result via the Activity's onActivityResult method.

IntentService approach

Down-sides:

More code and complexity than AsyncTask, though not as much as you might think

Will queue requests and run them on a single background thread. You can easily control this by replacing IntentService with an equivalent Service implementation, perhaps like this one.

Um, I can't think of any others right now actually

Up-sides:

Avoids the short-term memory leak problem

If your activity restarts while network operations are in-flight it can still receive the result of the download via its onActivityResult method

Better platform than AsyncTask to build and re-use robust networking code. Example: if you need to do an important upload, you could do it from AsyncTask in an Activity, but if the user context-switches out of the app to take a phone-call, the system may kill the app before the upload completes. It is less likely to kill an application with an active Service.

If you use your own concurrent version of IntentService (like the one I linked above) you can control the level of concurrency via the Executor.

Implementation summary

You can implement an IntentService to perform downloads on a single background thread quite easily.

Step 1: Create an IntentService to perform the download. You can tell it what to download via Intent extra's, and pass it a PendingIntent to use to return the result to the 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);

        }

    }

}

Step 2: Register the service in the manifest:

<service

        android:name=".DownloadIntentService"

        android:exported="false"/>

Step 3: Invoke the service from the Activity, passing a PendingResult object which the Service will use to return the result:

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

Step 4: Handle the result in 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);

}

A github project containing a complete working Android-Studio/gradle project is available here.

IntentService is the correct way to do this, not uprooting because AsyncTask is exactly the way not to do it. — Sep 10 '16 at 14:59
@BrillPappin I almost entirely agree and have re-worded to emphasize the drawbacks of AsyncTask. (I still think there are a very small number of cases where - if you really know what you are doing - it might be OK to use AsyncTask, but the accepted answer doesn't point out any drawbacks and is way too popular for the good of Android). — Mar 13 '17 at 12:56
Do you actually need IllustrativeRSS? What if you're not working with RSS stuff? — Apr 14 '18 at 19:13

Community♦ 11 · Accepted Answer · 2017-05-23 12:26:38Z

66

Do not use strictMode (only in debug mode)

Do not change SDK version

Do not use a separate thread

Use Service or AsyncTask

ReST over HTTP

Typically Json, can be XML or something else

Full API Access

Let's say you are writing an app that lets users track stock prices, interest rates and currecy exchange rates. You find an Json API that looks something like this:

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

This is an excellent choice for an API with multiple endpoints and allows you to declare the ReST endpoints instead of having to code them individually as with other libraries like ion or Volley. (website: http://square.github.io/retrofit/)

How do you use it with the finances API?

build.gradle

Add these lines to your Module level buid.gradle:

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

    }

}

FinancesFragment snippet

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

    }

}

If your API requires an API Key or other header like a user token, etc. to be sent, Retrofit makes this easy (see this awesome answer for details: https://stackoverflow.com/a/42899766/1024412).

One off ReST API access

Let's say you're building a "mood weather" app that looks up the users GPS location and checks the current temperature in that area and tells them the mood. This type of app doesn't need to declare API endpoints; it just needs to be able to access one API endpoint.

Ion

This is a great library for this type of access.

Please read msysmilu's great answer (https://stackoverflow.com/a/28559884/1024412)

Load images via HTTP

Volley

Volley can also be used for ReST APIs, but due to the more complicated setup required I prefer to use Retrofit from Square as above (http://square.github.io/retrofit/)

Let's say you are building a social networking app and want to load profile pictures of friends.

build.gradle

Add this line to your Module level buid.gradle:

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

ImageFetch.java

Volley requires more setup than Retrofit. You will need to create a class like this to setup a RequestQueue, an ImageLoader and an ImageCache, but it's not too bad:

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

Add the following to your layout xml file to add an image:

<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

Add the following code to the onCreate method (Fragment, Activity) or the constructor (Dialog):

NetworkImageView profilePicture = view.findViewById(R.id.profile_picture);

profilePicture.setImageUrl("http://example.com/users/images/profile.jpg", ImageFetch.getImageLoader(getContext());

Picasso

Another excellent library from Square. Please see the site for some great examples: http://square.github.io/picasso/

this should be the better answer than the original one as it simplifies the implementation of networking on android in the present world 2017, and most of the real world application uses very good libraries like these. — Nov 28 '17 at 11:46

msysmilumsysmilu 1,6101617 · Accepted Answer · 2015-02-17 10:31:31Z

Although above there is a huge solution pool, no one mentioned com.koushikdutta.ion: https://github.com/koush/ion

It's also asynchronous and very simple to use:

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

    }

});

score 8 · Accepted Answer · 2017-11-05 04:41:03Z

New Thread and AsyncTask solutions have been explained already.

AsyncTask should ideally be used for short operations. Normal Thread is not preferable for Android.

Have a look at alternate solution using HandlerThread and Handler

HandlerThread

Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.

Handler:

A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thread and that thread's message queue. When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it -- from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

Solution:

Create HandlerThread

Call start() on HandlerThread

Create Handler by getting Looper from HanlerThread

Embed your Network operation related code in Runnable object

Submit Runnable task to Handler

Sample code snippet, which address 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);

Pros of using this approach:

Creating new Thread/AsyncTask for each network operation is expensive. The Thread/AsyncTask will be destroyed and re-created for next Network operations. But with Handler and HandlerThread approach, you can submit many network operations (as Runnable tasks) to single HandlerThread by using Handler.

KacyKacy 1,50022032 · Accepted Answer · 2015-02-13 23:10:17Z

This works. Just made Dr.Luiji's answer a little simpler.

new Thread() {

    @Override

    public void run() {

        try {

            //Your code goes here

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}.start();

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:32:51Z

7

On Android, network operations cannot be run on the main thread. You can use Thread, AsyncTask (short-running tasks), Service (long-running tasks) to do network operations.

edited Jun 25 '16 at 9:32

Peter Mortensen

13.5k1984111

answered Jun 25 '15 at 7:42

Ponsuyambu Velladurai

1,05411331

add a comment |

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:35:31Z

7

Accessing network resources from the main (UI) thread cause this exception. Use a separate thread or AsyncTask for accessing a network resource to avoid this problem.

edited Jun 25 '16 at 9:35

Peter Mortensen

13.5k1984111

answered Aug 13 '15 at 8:26

RevanthKrishnaKumar V.

1,48411530

add a comment |

Ravindra babu 29.4k5157135 · Accepted Answer · 2017-10-10 07:52:47Z

RxAndroid is another better alternative to this problem and it saves us from hassles of creating threads and then posting results on Android UI thread.
We just need to specify threads on which tasks need to be executed and everything is handled internally.

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

    }

});

By specifiying (Schedulers.io()),RxAndroid will run getFavoriteMusicShows() on a different thread.

By using AndroidSchedulers.mainThread() we want to observe this Observable on the UI thread, i.e. we want our onNext() callback to be called on the UI thread

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:39:03Z

You are not allowed to implement network operations on the UI thread on Android. You will have to use AsyncTask class to perform network related operations like sending API request, downloading image from a URL, etc. and using callback methods of AsyncTask, you can get you result in onPostExecute menthod and you will be in the UI thread and you can populate UI with data from web service or something like that.

Example: Suppose you want to download image from an URL: https://www.samplewebsite.com/sampleimage.jpg

Solution using AsyncTask:
are respectively.

    public class MyDownloader extends AsyncTask<String,Void,Bitmap>

    {

        @Override

        protected void onPreExecute() {

            // Show progress dialog

            super.onPreExecute();

        }



        @Override

        protected void onPostExecute(Bitmap bitmap) {

            //Populate Ui

            super.onPostExecute(bitmap);

        }



        @Override

        protected Bitmap doInBackground(String... params) {

            // Open URL connection read bitmaps and return form here

            return result;

        }



        @Override

        protected void onProgressUpdate(Void... values) {

            // Show progress update

            super.onProgressUpdate(values);

        }





    }

}

Note: Do not forget to add the Internet permission in the Android manifest file. It will work like a charm. :)

Peter Mortensen 13.5k1984111 · Accepted Answer · 2016-06-25 09:48:34Z

There is another very convenient way for tackling this issue - use rxJava's concurrency capabilities. You can execute any task in background and post results to main thread in a very convenient way, so these results will be handed to processing chain.

The first verified answer advice is to use AsynTask. Yes, this is a solution, but it is obsolete nowadays, because there are new tools around.

String getUrl() {

    return "SomeUrl";

}



private Object makeCallParseResponse(String url) {

    return null;

    //

}



private void processResponse(Object o) {



}

The getUrl method provides the URL address, and it will be executed on the main thread.

makeCallParseResponse(..) - does actual work

processResponse(..) - will handle result on main thread.

The code for asynchronous execution will look like:

rx.Observable.defer(new Func0<rx.Observable<String>>() {

    @Override

    public rx.Observable<String> call() {

        return rx.Observable.just(getUrl());

    }

})

    .subscribeOn(Schedulers.io())

    .observeOn(Schedulers.io())

    .map(new Func1<String, Object>() {

        @Override

        public Object call(final String s) {

            return makeCallParseResponse(s);

        }

    })

    .observeOn(AndroidSchedulers.mainThread())

    .subscribe(new Action1<Object>() {

        @Override

        public void call(Object o) {

             processResponse(o);

        }

    },

    new Action1<Throwable>() {

        @Override

        public void call(Throwable throwable) {

            // Process error here, it will be posted on

            // the main thread

        }

    });

Compared to AsyncTask, this method allow to switch schedulers an arbitrary number of times (say, fetch data on one scheduler and process those data on another (say, Scheduler.computation()). You can also define you own schedulers.

In order to use this library, include following lines into you build.gradle file:

   compile 'io.reactivex:rxjava:1.1.5'

   compile 'io.reactivex:rxandroid:1.2.0'

The last dependency includes support for the .mainThread() scheduler.

There is an excellent ebook for rx-java.

quite an extensive approach it would to be schedule by our own and i don't know why we should if it is already being an option on Android side? — Sep 15 '16 at 14:10

Category

Random preview

How do I fix android.os.NetworkOnMainThreadException?

50 Answers 50

IntentService approach

Implementation summary

ReST over HTTP

Full API Access

Retrofit from Square

One off ReST API access

Ion

Load images via HTTP

Volley

Picasso

protected by Jorgesys Jan 28 '14 at 18:29

50 Answers 50

50 Answers 50

IntentService approach

Implementation summary

IntentService approach

Implementation summary

IntentService approach

Implementation summary

IntentService approach

Implementation summary

ReST over HTTP

Full API Access

Retrofit from Square

One off ReST API access

Ion

Load images via HTTP

Volley

Picasso

ReST over HTTP

Full API Access

Retrofit from Square

One off ReST API access

Ion

Load images via HTTP

Volley

Picasso

ReST over HTTP

Full API Access

Retrofit from Square

One off ReST API access

Ion

Load images via HTTP

Volley

Picasso

ReST over HTTP

Full API Access

Retrofit from Square

One off ReST API access

Ion

Load images via HTTP

Volley

Picasso

protected by Jorgesys Jan 28 '14 at 18:29

Popular posts from this blog

MongoDB - Not Authorized To Execute Command

in spring boot 2.1 many test slices are not allowed anymore due to multiple @BootstrapWith

How to fix TextFormField cause rebuild widget in Flutter

50 Answers
50

50 Answers
50

50 Answers
50