android.os.NetworkOnMainThreadException error in using Android's HttpURLConnection

NetworkOnMainThreadException : Raised when you try to perform operations on the main thread, which is wrong.

If you use StrictMode.ThreadPolicy.Builder to allow any operation it works but you are disabling a policy that is not supposed to allow certain behavior in the application, in this case operations on the main Thread, this is mainly used for development, for production you shouldn't use it .

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

Use runOnUiThread()

    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            try {  
               proceso(); //Realizar aquí tu proceso!                    

            } catch (Exception e) {
                Log.e("Error", "Exception: " + e.getMessage());
            }
        }
    });

Other options are Asynctask and also Handler.post() .

I found this excellent article for more information: "Android Background Tasks (I): Thread and AsyncTask" (Salvador Gómez's blog).

You should use AsynkTask:

AsyncTask.execute(new Runnable() {
    @Override
    public void run() {
        try {
            URL url = new URL("http://localhost/testrealm/api/v1/status");
            HttpURLConnection urlConnection = null;

            urlConnection = (HttpURLConnection) url.openConnection();
            InputStream in = new BufferedInputStream(urlConnection.getInputStream());

            Log.d(TAG, "get json: " + in.toString());
            urlConnection.disconnect();

        } catch (IOException e) {
            e.printStackTrace();
        }        
    }
});

If you need to know when you get a response and/or modify views after the call, use AsynkTask like this:

new AsyncTask<Void,Void,Void>(){
    @Override
    protected Void doInBackground(Void... voids) {
        try {
           URL url = new URL("http://localhost/testrealm/api/v1/status");
           HttpURLConnection urlConnection = null;

           urlConnection = (HttpURLConnection) url.openConnection();
           InputStream in = new BufferedInputStream(urlConnection.getInputStream());

            Log.d(TAG, "get json: " + in.toString());
            urlConnection.disconnect();

        } catch (IOException e) {
            e.printStackTrace();
        } 
        return null;
     }

     @Override
     protected void onPostExecute(Void aVoid) {
          // your code here
          super.onPostExecute(aVoid);
     }
};

Add the following code before making the web request withHttpURLConnection

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

As another option to this problem, which I also passed through my hands, is to implement your code inside a runOnUiThread()that will allow access to the variables of the main thread, since that is exactly the problem.

In this question, I explain this method:

Use Activity.runOnUiThread() or Handler.post(Runnable) to update main Thread?

As soon as I have the opportunity again, I will try your solution and thus learn about other possible solutions.

This topic is always something to talk about. Disabling policies is definitely not the option.

But beware that this has a lot to do with how you want to do things, in my experience I have seen the following scenarios:

1. Run a long process in the background informing the user of its progress
2. Running a long process in the background without the user knowing about it
3. Run a process in the background and perform another process according to its result.

Therefore, I do not know what your case is and it is important that you think about it. For the first case AsyncTaskit is very good for you. You execute your heavy process in doInBackgroundit, you inform the user about its progress in it publishProgressand at the end you show the result on his screen through the onPostExecute. It is the usual, not only to make requests to servers, it is also valid for complicated calculations, database searches, etc. As long as your intention is to keep the user waiting for this process (something that can be annoying) and that they can interact with the app once it has finished.

For the second case, one Threador one Runnabletogether with one Handlercomes in handy, you execute a process in a method runthat is independent of its completion status and the user is not even aware of this.

For the third case, let's take an example: You have a process that captures data and transforms it into useful information, you save this information in your local database but you must also send it to the server for reasons of data redundancy; but you must also wait for the result of the sending to the server to update an indicator on the record that defines if the sending was successful or not, so as not to send it again, for example. For this type of situation, it is convenient to work with Thread schedulers that allow you to execute an action for the moment in which the thread finishes its execution. A very simple example is Google Guava and its classes Futuresand ListenableFuture.

It is a bit of additional information to what you have been answered that is good to know, so define your scenarios well so that you can choose a better way to work.