Android Error.os.NetworkOnMainThreadException in using Android HttpURLConnection

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 receive 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 performing the web request with HttpURLConnection

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

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

In this question, I explain this method:

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

As soon as I have the opportunity again I will test your solution and thus know well other possible solutions.

This topic is always something to talk about. Definitely disabling policies is 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 background process and perform another process according to your result.

Therefore, I do not know what your case is and it is important that you think about it. For the first case AsyncTask it suits you very well. You run your heavy process on the doInBackground, you inform the user about the progress of the same on the publishProgress and at the end you show the result on your screen through the onPostExecute. It is the usual, not only to make requests to servers, it also applies to complicated calculations, database searches, etc. as long as your intention it is to keep the user waiting for that process (something that can be annoying) and that he can interact with the app once it has finished.

For the second case a Thread or a Runnable along with a Handler comes in handy, you run a process in a run method that is independent of its completion State and the user doesn't even know about it.

For the third case, let's take an example: you have a process that captures data and transforms it into useful information, this information is saved in your local database but you must also send it to the server for data redundancy reasons; but you must also wait for the result of the send to the server to update an indicator about the record that defines you whether the Send was successful or not, so as not to send it again for example. For this type of situation, it is best to work with thread schedulers that allow you to execute an action by the time the thread ends its execution. A a very simple example is Google Guava and its classes Futures and ListenableFuture.

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