[ Dúvida][ Desenvolvimento] Como fazer uma conexão HTTP no Android? [RESOLVIDO]

Olá galera,
Seguinte, eu gostaria de saber como fazer conexão com a web, fazer requisições e tal no Android, tem poucos tutoriais sobre, e o que tem, não me ajudou muito. Se também puderem exemplificar em código, ficaria mais grato ainda.
Obrigado pela atenção.

package com.example.android.networkconnect;



/**

 * Created by gruber on 31/08/17.

 */



import android.content.Context;

import android.net.ConnectivityManager;

import android.net.NetworkInfo;

import android.os.AsyncTask;

import android.os.Bundle;

import android.support.annotation.Nullable;

import android.support.v4.app.Fragment;

import android.support.v4.app.FragmentManager;

import android.util.Log;





import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.net.URL;



import java.net.HttpURLConnection;



/**

 * Implementation of headless Fragment that runs an AsyncTask to fetch data from the network.

 */

public class NetworkFragmentHTTP extends Fragment {

    public static final String TAG = "NetworkFragment";



    private static final String URL_KEY = "UrlKey";



    private DownloadCallback mCallback;

    private DownloadTask mDownloadTask;

    private String mUrlString;



    /**

     * Static initializer for NetworkFragment that sets the URL of the host it will be downloading

     * from.

     */

    public static NetworkFragmentHTTP getInstance(FragmentManager fragmentManager, String url) {

        // Recover NetworkFragment in case we are re-creating the Activity due to a config change.

        // This is necessary because NetworkFragment might have a task that began running before

        // the config change and has not finished yet.

        // The NetworkFragment is recoverable via this method because it calls

        // setRetainInstance(true) upon creation.

        NetworkFragmentHTTP networkFragment = (NetworkFragmentHTTP) fragmentManager

                .findFragmentByTag(NetworkFragment.TAG);

        if (networkFragment == null) {

            networkFragment = new NetworkFragmentHTTP();

            Bundle args = new Bundle();

            args.putString(URL_KEY, url);

            networkFragment.setArguments(args);

            fragmentManager.beginTransaction().add(networkFragment, TAG).commit();

        }

        return networkFragment;

    }



    @Override

    public void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // Retain this Fragment across configuration changes in the host Activity.

        setRetainInstance(true);

        mUrlString = getArguments().getString(URL_KEY);

    }



    @Override

    public void onAttach(Context context) {

        super.onAttach(context);

        // Host Activity will handle callbacks from task.

        mCallback = (DownloadCallback) context;

    }



    @Override

    public void onDetach() {

        super.onDetach();

        // Clear reference to host Activity.

        mCallback = null;

    }



    @Override

    public void onDestroy() {

        // Cancel task when Fragment is destroyed.

        cancelDownload();

        super.onDestroy();

    }



    /**

     * Start non-blocking execution of DownloadTask.

     */

    public void startDownload() {

        cancelDownload();

        mDownloadTask = new DownloadTask();

        mDownloadTask.execute(mUrlString);

    }



    /**

     * Cancel (and interrupt if necessary) any ongoing DownloadTask execution.

     */

    public void cancelDownload() {

        if (mDownloadTask != null) {

            mDownloadTask.cancel(true);

            mDownloadTask = null;

        }

    }



    /**

     * Implementation of AsyncTask that runs a network operation on a background thread.

     */

    private class DownloadTask extends AsyncTask<String, Integer, DownloadTask.Result> {



        /**

         * Wrapper class that serves as a union of a result value and an exception. When the

         * download task has completed, either the result value or exception can be a non-null

         * value. This allows you to pass exceptions to the UI thread that were thrown during

         * doInBackground().

         */

        class Result {

            public String mResultValue;

            public Exception mException;



            public Result(String resultValue) {

                mResultValue = resultValue;

            }



            public Result(Exception exception) {

                mException = exception;

            }

        }



        /**

         * Cancel background network operation if we do not have network connectivity.

         */

        @Override

        protected void onPreExecute() {

            if (mCallback != null) {

                NetworkInfo networkInfo = mCallback.getActiveNetworkInfo();

                if (networkInfo == null || !networkInfo.isConnected() ||

                        (networkInfo.getType() != ConnectivityManager.TYPE_WIFI

                                && networkInfo.getType() != ConnectivityManager.TYPE_MOBILE)) {

                    // If no connectivity, cancel task and update Callback with null data.

                    mCallback.updateFromDownload(null);

                    cancel(true);

                }

            }

        }



        /**

         * Defines work to perform on the background thread.

         */

        @Override

        protected Result doInBackground(String... urls) {

            Result result = null;

            if (!isCancelled() && urls != null && urls.length > 0) {

                String urlString = urls[0];

                try {

                    URL url = new URL(urlString);

                    String resultString = downloadUrl(url);

                    if (resultString != null) {

                        result = new Result(resultString);

                    } else {

                        throw new IOException("No response received.");

                    }

                } catch (Exception e) {

                    result = new Result(e);

                }

            }

            return result;

        }



        /**

         * Send DownloadCallback a progress update.

         */

        @Override

        protected void onProgressUpdate(Integer... values) {

            super.onProgressUpdate(values);

            if (values.length >= 2) {

                mCallback.onProgressUpdate(values[0], values[1]);

            }

        }



        /**

         * Updates the DownloadCallback with the result.

         */

        @Override

        protected void onPostExecute(Result result) {

            if (result != null && mCallback != null) {

                if (result.mException != null) {

                    mCallback.updateFromDownload(result.mException.getMessage());

                } else if (result.mResultValue != null) {

                    mCallback.updateFromDownload(result.mResultValue);

                }

                mCallback.finishDownloading();

            }

        }



        /**

         * Override to add special behavior for cancelled AsyncTask.

         */

        @Override

        protected void onCancelled(Result result) {

        }



        /**

         * Given a URL, sets up a connection and gets the HTTP response body from the server.

         * If the network request is successful, it returns the response body in String form. Otherwise,

         * it will throw an IOException.

         */

        private String downloadUrl(URL url) throws IOException {

            InputStream stream = null;

            HttpURLConnection connection = null;

            String result = null;

            try {

                connection = (HttpURLConnection) url.openConnection();

                // Timeout for reading InputStream arbitrarily set to 3000ms.

                connection.setReadTimeout(3000);

                // Timeout for connection.connect() arbitrarily set to 3000ms.

                connection.setConnectTimeout(3000);

                // For this use case, set HTTP method to GET.

                connection.setRequestMethod("GET");

                // Already true by default but setting just in case; needs to be true since this request

                // is carrying an input (response) body.

                connection.setDoInput(true);

                // Open communications link (network traffic occurs here).

                connection.connect();

                publishProgress(DownloadCallback.Progress.CONNECT_SUCCESS);

                int responseCode = connection.getResponseCode();

                if (responseCode != HttpURLConnection.HTTP_OK) {

                    throw new IOException("HTTP error code: " + responseCode);

                }

                // Retrieve the response body as an InputStream.

                stream = connection.getInputStream();

                publishProgress(DownloadCallback.Progress.GET_INPUT_STREAM_SUCCESS, 0);

                if (stream != null) {

                    // Converts Stream to String with max length of 500.

                    result = readStream(stream, 500);

                    publishProgress(DownloadCallback.Progress.PROCESS_INPUT_STREAM_SUCCESS, 0);

                }

            } finally {

                // Close Stream and disconnect HTTPS connection.

                if (stream != null) {

                    stream.close();

                }

                if (connection != null) {

                    connection.disconnect();

                }

            }

            return result;

        }



        /**

         * Converts the contents of an InputStream to a String.

         */

        private String readStream(InputStream stream, int maxLength) throws IOException {

            String result = null;

            // Read InputStream using the UTF-8 charset.

            InputStreamReader reader = new InputStreamReader(stream, "UTF-8");

            // Create temporary buffer to hold Stream data with specified max length.

            char[] buffer = new char[maxLength];

            // Populate temporary buffer with Stream data.

            int numChars = 0;

            int readSize = 0;

            while (numChars < maxLength && readSize != -1) {

                numChars += readSize;

                int pct = (100 * numChars) / maxLength;

                publishProgress(DownloadCallback.Progress.PROCESS_INPUT_STREAM_IN_PROGRESS, pct);

                readSize = reader.read(buffer, numChars, buffer.length - numChars);

            }

            if (numChars != -1) {

                // The stream was not empty.

                // Create String that is actual length of response body if actual length was less than

                // max length.

                numChars = Math.min(numChars, maxLength);

                result = new String(buffer, 0, numChars);

            }

            return result;

        }

    }

}