How to fix android os NetworkOnMainThreadException

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

User · Answer

If you are working in kotlin and anko you can add    doAsync      method

User · Answer

The NetworkOnMainThread exception occurs because you have called some network operation on the default thread  that is  the UI thread   As per Android version Android nbsp 3  Honeycomb  which is not allowed  you should call network operation outside the main thread   You can use AsyncTask  IntentService  or creating your own thread and calling inside the run method  For more information  visit Connecting to the Network

User · Answer

For me it was this    lt uses-sdk         android minSdkVersion  8          android targetSdkVersion  10    gt    The device I was testing my app on was 4 1 2 which is SDK Version 16   Make the sure the target version is the same as your Android Target Library  If you are unsure what your target library is  right click your Project -  Build Path -  Android  and it should be the one that is ticked   Also  as others have mentioned  include the correct permissions to access the Internet    lt uses-permission android name  android permission INTERNET   gt

User · Answer

Android does not allow a separate process into the main activity thread  and the HTTP connection is an independent thread here  That is the reason you are getting the  android os NetworkOnMainThreadException    There can be a need where you want to check the actual Internet connection before showing webview to the user  because if there is not Internet the web view will show the page not found error to the user  which normally you don t what to show   For checking Internet availability  the ping command can be used  but in case of Wi-Fi pinging can be disabled at the Wi-Fi server  so in this case you use an HTTP connection to check the status of the request   This can be the right approach if you are checking your own webview URL link before showing a webview to the user  In this case  you can use the strict mode of Android  but don t permit all the policy because you don t need it   You should only give network allow policy for the strict mode  Just add the below line into your code  and you will not get this error   StrictMode ThreadPolicy policy   new StrictMode ThreadPolicy Builder   permitNetwork   build    StrictMode setThreadPolicy policy

User · Answer

You can actually start a new Thread  I had this problem before and solved it by this way

User · Answer

Use the below code to perform heavy tasks      Your package here   import java util List  import org apache http NameValuePair   import android app Activity  import android app ProgressDialog  import android content Context  import android os AsyncTask  import android view View OnSystemUiVisibilityChangeListener   public class AsyncRequest extends AsyncTask lt String  Integer  String gt         Context context      ProgressDialog pDialog          Three Constructors     public AsyncRequest Activity a  String m  List lt NameValuePair gt  p            context   a          method   m          parameters   p             public AsyncRequest Activity a            this caller    OnAsyncRequestComplete  a          context   a             public String doInBackground String    urls               Perform your task here         return result             public void onPreExecute             pDialog   new ProgressDialog context           pDialog setMessage  Please wait              pDialog setCancelable false           pDialog show               public void onProgressUpdate Integer    progress               You can implement some progressBar and update it in this record               setProgressPercent progress 0               public void onPostExecute String response            if  pDialog    null  amp  amp  pDialog isShowing                  pDialog dismiss                         Get the result here            protected void onCancelled String response             if  pDialog    null  amp  amp  pDialog isShowing                  pDialog dismiss

User · Answer

The main thread is the UI thread  and you cannot do an operation in the main thread which may block the user interaction  You can solve this in two ways   Force to do the task in the main thread like this  StrictMode ThreadPolicy threadPolicy   new StrictMode ThreadPolicy Builder   permitAll   build    StrictMode setThreadPolicy threadPolicy     Or create a simple handler and update the main thread if you want   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     And to stop the thread use   newHandler removeCallbacks runnable     For more information check this out  Painless threading

User · Answer

These answers need to be updated to use more contemporary way to connect to servers on Internet and to process asynchronous tasks in general  e g  you can find examples where Tasks are used in Google Drive API sample  The same should be used in this case  I ll use OP s original code to demonstrate this approach   First  you ll need to define an off-main thread executor and you need to do it only once           private val mExecutor  Executor   Executors newSingleThreadExecutor     Then process your logic in that executor  which will be running off main thread           Tasks call  mExecutor  Callable lt String gt                     val url   URL urlToRssFeed                  val factory   SAXParserFactory newInstance                   val parser   factory newSAXParser                   val xmlreader   parser getXMLReader                   val theRSSHandler   RssHandler                   xmlreader setContentHandler theRSSHandler                  val is   InputSource url openStream                    xmlreader parse is                  theRSSHandler getFeed                      complete processing and return String or other object                    e g  you could return Boolean indicating a success or failure                 return Callable someResult            continueWith                 it result here is what your asynchronous task has returned             processResult it result              continueWith clause will be executed after your asynchronous task is completed and you will have an access to a value that has been returned by the task through it result

User · Answer

Do not use strictMode  only in debug mode  Do not change SDK version Do not use a separate thread   Use Service or AsyncTask  See also Stack nbsp Overflow question   android os NetworkOnMainThreadException sending an email from Android

User · Answer

There are two Solution of this Problem   1  Don t write network call in Main UI Thread  Use Async Task for that   2  Write below code into your MainActivity file after setContentView R layout activity main    if  android os Build VERSION SDK INT  gt  9        StrictMode ThreadPolicy policy   new StrictMode ThreadPolicy Builder   permitAll   build        StrictMode setThreadPolicy policy       And below import statement into your java file   import android os StrictMode

User · Answer

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 running 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    lt service         android name   DownloadIntentService          android exported  false   gt    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

User · Answer

Kotlin version internal class RetrieveFeedTask   AsyncTask lt String  Void  RSSFeed gt           override fun doInBackground vararg urls  String   RSSFeed             try                   download                 prepare RSSFeeds              return RSSFeeds             catch  e  Exception                   handle exception             return null                      override fun onPostExecute feed  RSSFeed               TODO  check this exception            TODO  do something with the feed          Call example  RetrieveFeedTask   execute url

User · Answer

Android Jetpack introduced WorkManager which fixes the problem of background service restriction in Oreo and use of Alarm Manager below Lolipop and JobScheduler above Lolipop   Please use WorkManager to run tasks on background thread and it s continue to run even after user closes the app

User · Answer

You can use Kotlin-coroutines   class YoutActivity   AppCompatActivity  CoroutineScope          override fun onCreate                 launch    yourHeavyMethod                    suspend fun yourHeavyMethod              with Dispatchers IO   yourNetworkCall                                                You can follow this guide

User · Answer

android os NetworkOnMainThreadException is thrown when network operations are performed on the main thread  You better do this in AsyncTask to remove this Exception  Write it this way       new AsyncTask lt Void String String gt               Override         protected Void doInBackground Void    params                   Perform your network operation                 Get JSON or XML string from the server                 Store in a local variable  say response  and return              return response                     protected void onPostExecute String results                  Response returned by doInBackGround   will be received                by onPostExecute String results                  Now manipulate your jason xml String results                    execute

User · Answer

This exception occurs due to any heavy task performed on the main thread if that performing task takes too much time   To avoid this  we can handle it using threads or executers  Executors newSingleThreadExecutor   submit new Runnable          Override     public void run                You can perform your task here

User · Answer

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

User · Answer

Here s a simple solution using OkHttp  Future  ExecutorService and Callable  final OkHttpClient httpClient   new OkHttpClient    final ExecutorService executor   newFixedThreadPool 3    final Request request   new Request Builder   url  quot http   example com quot   build     Response response   executor submit new Callable lt Response gt         public Response call   throws IOException         return httpClient newCall request  execute            get

User · Answer

AsyncTasks should ideally be used for short operations  a few seconds   at the most   - developer-android   Using newCachedThreadPool is the good one  also you can consider other options like newSingleThreadExecutor  newFixedThreadPool      ExecutorService myExecutor   Executors newCachedThreadPool        myExecutor execute new Runnable              Override         public void run                 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                          ThreadPoolExecutor is a helper class to make this process easier  This   class manages the creation of a group of threads  sets their   priorities  and manages how work is distributed among those threads    As workload increases or decreases  the class spins up or destroys   more threads to adjust to the workload    See this for more info about Android threads

User · Answer

Google deprecated the Android AsyncTask API in Android 11  even if you create a thread class outside the main activity  just by calling it in main you will get the same error  the calls must be inside a runnable thread  but if you need some asynchronous code to execute on the background or some on post afterwards here you can check out some alternatives for both Kotlin and Java https   stackoverflow com questions 58767733 android-asynctask-api-deprecating-in-android-11-what-are-the-alternatives  the one that worked for me specifically was an answer by mayank1513 for a java 8 implementation of runnable thread found on the above link  code is as follows new Thread    - gt               do background stuff here         runOnUiThread   - gt                  OnPostExecute stuff here                    start     However you can define the thread first in some part of your code and start it somewhere else like this thread definition Thread thread   new Thread    - gt                   do background stuff here             runOnUiThread   - gt                      OnPostExecute stuff here                              thread call thread start     hope this saves someone the headache of seeing deprecated AsyncTask

User · Answer

You can either use KOTLIN and ANKO    Kotlin is new official language for Android more about it you can find here https   kotlinlang org docs tutorials kotlin-android html  Anko supported library for Kotlin in Android  some doc here https   github com Kotlin anko  The solution which is really useful and have only few lines of code written by  AntonioLeiva  https   antonioleiva com anko-background-kotlin-android   doAsync       var result   runLongTask       uiThread           toast result            Simple as it is  NetworkOnMainThread occurs when you run background job on UI Thread so one thing you have to do is to run your longTask job in the background  You can do this using this method and Kotlin with Anko in your Android App

User · Answer

As Android is working on a single thread  you should not do any network operation on the main thread  There are various ways to avoid this   Use the following way to perform a network operation   Asysnctask  For small operations which don t take much time  Intent Service  For network operation which take a big amount of time  Use a custom library like Volley and Retrofit for handling complex network operations   Never use StrictMode setThreadPolicy policy   as it will freeze your UI and is not at all a good idea

User · Answer

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  android os NetworkOnMainThreadException is thrown when an application attempts to perform a networking operation on its main thread  If your task took above five seconds  it takes a force close   Run your code in AsyncTask   class FeedTask extends AsyncTask lt String  Void  Boolean gt         protected RSSFeed doInBackground String    urls              TODO  Connect            protected void onPostExecute RSSFeed feed               TODO  Check this exception            TODO  Do something with the feed           OR  new Thread new Runnable         Override     public void run             try                  Your implementation                   catch  Exception ex                ex printStackTrace                       start      This is not recommended  But for DEBUG purpose you can disable the strict mode as well using the following code   if  android os Build VERSION SDK INT  gt  9        StrictMode ThreadPolicy policy            new StrictMode ThreadPolicy Builder   permitAll   build        StrictMode setThreadPolicy policy

User · Answer

You can not call network on the main thread or UI thread  On Android if you want to call network there are two options -   Call asynctask  which will run one background thread to handle the network operation  You can create your own runnable thread to handle the network operation    Personally I prefer asynctask  For further information you can refer this link

User · Answer

This is only thrown for applications targeting the Honeycomb SDK or higher  Applications targeting earlier SDK versions are allowed to do networking on their main event loop threads   The error is the SDK warning

User · Answer

How to fix android os NetworkOnMainThreadException  What is NetworkOnMainThreadException   In Android all the UI operations we have to do on the UI thread  main thread   If we perform background operations or some network operation on the main thread then we risk this exception will occur and the app will not respond   How to fix it   To avoid this problem  you have to use another thread for background operations or network operations  like using asyncTask and use some library for network operations like Volley  AsyncHttp  etc

User · Answer

You should not do any time-consuming task on the main thread  UI thread   like any network operation  file I O  or SQLite database operations  So for this kind of operation  you should create a worker thread  but the problem is that you can not directly perform any UI related operation from your worker thread  For that  you have to use Handler and pass the Message    To simplify all these things  Android provides various ways  like AsyncTask  AsyncTaskLoader  CursorLoader or IntentService  So you can use any of these according to your requirements

User · Answer

You can also resolve this issue by using Strict Mode using the below code  It s also an alternative to resolving this issue   StrictMode ThreadPolicy policy   new StrictMode ThreadPolicy Builder   permitAll   build    StrictMode setThreadPolicy policy     But the best practice would be to use AsyncTask

User · Answer

You disable the strict mode using following code   if  android os Build VERSION SDK INT  gt  9        StrictMode ThreadPolicy policy            new StrictMode ThreadPolicy Builder   permitAll   build        StrictMode setThreadPolicy policy       This is not recommended  use the AsyncTask interface   Full code for both the methods

User · Answer

NOTE   AsyncTask was deprecated in API level 30  https   developer android com reference android os AsyncTask 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 lt String  Void  RSSFeed gt         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   lt uses-permission android name  quot android permission INTERNET quot   gt

User · Answer

I solved this problem in a simple way     I added after oncreate StrictMode enableDefaults    and solved this   Or  use Service or AsyncTask to solve this  Note   Do not change SDK version Do not use a separate thread   For more  check this

User · Answer

Different options    use normal java runnable thread to process network task and can use runOnUIThread   to update the UI intentservice  async task can be used in case you want to update the UI after getting network response

User · Answer

Android does not allow to run long running operations on the main thread  So just use a different thread and post result to main thread when needed  new Thread new Runnable              Override         public void run                                   run operation here                              after getting result             runOnUiThread new Runnable                      Override                 public void run                           post result to main thread                                                    start

User · Answer

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          lt uses-permission android name  android permission INTERNET   gt    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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

As of 2018  I would recommend to use RxJava in Kotlin for network fetching  A simple example is below   Single fromCallable              Your Network Fetching Code         Network fetchHttp url              subscribeOn Schedulers io         observeOn AndroidSchedulers mainThread         subscribe              What you need to do with your result on the view          result - gt  view updateScreen result

User · Answer

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 lt JsonObject gt          Override     public void onCompleted Exception e  JsonObject result               do stuff with the result or error

User · Answer

The top answer of spektom works perfect   If you are writing the AsyncTask inline and not extending as a class  and on top of this  if there is a need to get a response out of the AsyncTask  one can use the get   method as below   RSSFeed feed   new RetreiveFeedTask   execute urlToRssFeed  get       From his example

User · Answer

This exception is thrown when an application attempts to perform a networking operation on its main thread  If your task took above five seconds  it takes a force close   Run your code in AsyncTask   class RetrieveFeedTask extends AsyncTask lt String  Void  Boolean gt         protected RSSFeed doInBackground String    urls              TODO  Connect            protected void onPostExecute RSSFeed feed               TODO  Check this exception            TODO  Do something with the feed

User · Answer

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 lt String Void Bitmap gt                 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

User · Answer

Kotlin  If you are using Kotlin  you can use a coroutine fun doSomeNetworkStuff         GlobalScope launch Dispatchers IO

User · Answer

Network-based operations cannot be run on the main thread  You need to run all network-based tasks on a child thread or implement AsyncTask   This is how you run a task in a child thread   new Thread new Runnable         Override     public void run             try                  Your implementation goes here                    catch  Exception ex                ex printStackTrace                       start

User · Answer

Do this in Background Thread using AsycTask  Java  class NetworkThread extends AsyncTask lt String  Void  String gt         protected Void doInBackground String    arg0              Your implementation            protected void onPostExecute String result               TODO  do something with the feed           Call wherever you need  new NetworkThread   execute  Your URL here      Kotlin  internal class MyNetworkTask   AsyncTask lt String  Void  RSSFeed gt           override fun doInBackground vararg urls  String   RSSFeed            try                   download                 prepare RSSFeeds              return RSSFeeds            catch  e  Exception                  handle exception             return null                      override fun onPostExecute feed  RSSFeed               TODO  check this exception            TODO  do something with the feed           Call in kotlin  MyNetworkTask   execute url

User · Answer

There are many great answers already on this question  but a lot of great libraries have come out since those answers were posted  This is intended as a kind of newbie-guide   I will cover several use cases for performing network operations and a solution or two for each   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 lt String gt  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 lt Stock gt  object http   api example com currencies                     ResponseWrapper lt String gt  object containing a list of currency abbreviation http   api example com currencies  currency           Currency object http   api example com currencies  id1 values  id2    PriceHistory lt Currency gt  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 lt ResponseWrapper lt String gt  gt  listStocks         GET  stocks  symbol        Call lt Stock gt  getStock  Path  symbol  String tickerSymbol        GET  stocks  symbol  prices       Call lt PriceHistory lt Stock gt  gt  getPriceHistory  Path  symbol  String tickerSymbol         GET  currencies       Call lt ResponseWrapper lt String gt  gt  listCurrencies         GET  currencies  symbol        Call lt Currency gt  getCurrency  Path  symbol  String currencySymbol        GET  currencies  symbol  values  compare symbol        Call lt PriceHistory lt Currency gt  gt  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 lt Stock gt          Override     public void onResponse Call lt Stock gt  stockCall  Response lt Stock gt  stockResponse           Stock stock   stockCall body              do something with the stock            Override     public void onResponse Call lt Stock gt  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 lt String  Bitmap gt  cache   new HashMap lt String  Bitmap gt                      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    lt 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   gt    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

User · Answer

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 lt List lt String gt  gt  musicShowsObservable   Observable fromCallable new Callable lt List lt String gt  gt           Override    public List lt String gt  call          return mRestClient getFavoriteMusicShows              mMusicShowSubscription   musicShowsObservable  subscribeOn Schedulers io     observeOn AndroidSchedulers mainThread     subscribe new Observer lt List lt String gt  gt            Override      public void onCompleted             Override      public void onError Throwable e            Override      public void onNext List lt String gt  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

User · Answer

This happens in Android 3 0 and above  From Android 3 0 and above  they have restricted using network operations  functions that access the Internet  from running in the main thread UI thread  what spawns from your on create and on resume methods in the activity    This is to encourage using separate threads for network operations  See AsyncTask for more details on how to perform network activities the right way

User · Answer

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 lt rx Observable lt String gt  gt           Override     public rx Observable lt String gt  call             return rx Observable just getUrl                   subscribeOn Schedulers io         observeOn Schedulers io         map new Func1 lt String  Object gt               Override         public Object call final String s                return makeCallParseResponse s                         observeOn AndroidSchedulers mainThread         subscribe new Action1 lt Object gt               Override         public void call Object o                 processResponse o                        new Action1 lt Throwable gt               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

User · Answer

Use this in Your Activity      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 lt Detailinfo gt                              for  int i   0  i  lt  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

User · Answer

You are able to move a part of your code into another thread to offload the main thread and avoid getting ANR  NetworkOnMainThreadException  IllegalStateException e g  Cannot access database on the main thread since it may potentially lock the UI for a long period of time   There are some approaches that you should choose depends on the situation Java Thread or Android HandlerThread  Java threads are one-time use only and die after executing its run method  HandlerThread is a handy class for starting a new thread that has a looper   AsyncTask  deprecated in API level 30   AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework  AsyncTasks should ideally be used for short operations  a few seconds at the most   If you need to keep threads running for long periods of time  it is highly recommended you use the various APIs provided by the java util concurrent package such as Executor  ThreadPoolExecutor and FutureTask   Since Main thread monopolizes UI components it is not possible to access to some View  that is why Handler is on the rescue Thread pool implementation ThreadPoolExecutor  ScheduledThreadPoolExecutor     ThreadPoolExecutor class that implements ExecutorService which gives fine control on the thread pool  Eg  core pool size  max pool size  keep alive time  etc   ScheduledThreadPoolExecutor - a class that extends ThreadPoolExecutor  It can schedule tasks after a given delay or periodically   FutureTask  FutureTask performs asynchronous processing  however  if the result is not ready yet or processing has not complete  calling get   will be block the thread  AsyncTaskLoaders  AsyncTaskLoaders as they solve a lot of problems that are inherent to AsyncTask  IntentService  This is the defacto choice for long running processing on Android  a good example would be to upload or download large files  The upload and download may continue even if the user exits the app and you certainly do not want to block the user from being able to use the app while these tasks are going on   JobScheduler  Effectively  you have to create a Service and create a job using JobInfo Builder that specifies your criteria for when to run the service   RxJava  Library for composing asynchronous and event-based programs by using observable sequences   Coroutines  Kotlin   The main gist of it is  it makes asynchronous code looks so much like synchronous  Read more here  here  here  here

User · Answer

Just to spell out something explicitly   The main thread is basically the UI thread   So saying that you cannot do networking operations in the main thread means you cannot do networking operations in the UI thread  which means you cannot do networking operations in a  runOnUiThread new Runnable            block inside some other thread  either    I just had a long head-scratching moment trying to figure out why I was getting that error somewhere other than my main thread   This was why  this thread helped  and hopefully this comment will help someone else

User · Answer

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

User · Answer

I had a similar problem  I just used the following in oncreate method of your activity     allow strict mode StrictMode ThreadPolicy policy   new StrictMode ThreadPolicy Builder   permitAll   build    StrictMode setThreadPolicy policy     and it worked well   Caveat is that using this for a network request that takes more than 100 miliseconds will cause noticeable UI freeze and potentially ANRs  Application Not Responding   so keep that in mind

User · Answer

Put your code inside   new Thread new Runnable         Override     public void run             try                  Your implementation                   catch  Exception ex                ex printStackTrace                       start      Or   class DemoTask extends AsyncTask lt Void  Void  Void gt         protected Void doInBackground Void    arg0              Your implementation            protected void onPostExecute Void result               TODO  do something with the feed

User · Answer

The error is due to executing long running operations in main thread You can easily rectify the problem by using AsynTask or Thread  You can checkout this library AsyncHTTPClient for better handling    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

User · Answer

We can also use RxJava to move network operations to a background thread  And it s fairly simple as well   webService doSomething someData             subscribeOn Schedulers newThread   -- This for background thread            observeOn AndroidSchedulers mainThread    -- for callback on UI                          subscribe result - gt  resultText setText  It worked                   e - gt  handleError e      You can do a lot more stuff with RxJava Here are some links for RxJava  Feel free to dig in    RxJava Async task in Android  http   blog stablekernel com replace-asynctask-asynctaskloader-rx-observable-rxjava-android-patterns

User · Answer

In simple words   DO NOT DO NETWORK WORK IN THE UI THREAD  For example  if you do an HTTP request  that is a network action   Solution    You have to create a new Thread Or use AsyncTask class   Way   Put all your works inside   run   method of new thread Or doInBackground   method of AsyncTask class    But   When you get something from Network response and want to show it on your view  like display response message in TextView   you need to return back to the UI thread   If you don t do it  you will get ViewRootImpl CalledFromWrongThreadException   How to    While using AsyncTask  update view from onPostExecute   method Or call runOnUiThread   method and update view inside the run   method

User · Answer

Do the network actions on another thread     For Example    new Thread new Runnable         Override     public void run                Do network action in this function          start      And add this to AndroidManifest xml       lt uses-permission android name  android permission INTERNET   gt

User · Answer

Never do any long running work on UI thread  that long running work can be communication with server  read write on file etc  These tasks should be on background thread  thats why Service  AsyncTask  Threads created  You can disable StrictMode that will prevent crash but that never recommended    I would suggest you take an advantage of StrictMode atleast in Debug mode  Use below code to get logs of any issue which slows down your App on main thread   StrictMode setThreadPolicy new StrictMode ThreadPolicy Builder                detectAll                penaltyLog                build       You can set different penalties -   penaltyLog      to print log penaltyDeath      This will crash you App so costly penalty  penaltyDialog      Show alert when something went lazy on Main thread   There is so much about https   developer android com reference android os StrictMode html

User · Answer

You have to simple add following line in manifest xml after manifest tag   lt uses-permission android name  android permission INTERNET   gt    and in activity file add following code after binding statement  if  android os Build VERSION SDK INT  gt  9       StrictMode ThreadPolicy policy   new StrictMode ThreadPolicy Builder   permitAll   build       StrictMode setThreadPolicy policy

User · Answer

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

User · Answer

Using Android Annotations is an option  It will allow you to simply run any method in a background thread      normal method private void normal         doSomething       do something in background     Background protected void doSomething           run your networking code here     Note  that although it provides benefits of simplicity and readability  it has its disadvantages

[java] How to fix 'android.os.NetworkOnMainThreadException'?

Examples related to java

Examples related to android

Examples related to android-networking

Examples related to networkonmainthread