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

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

José Gabriel Gruber
Gruber

(usa Manjaro Linux)

Enviado em 31/08/2017 - 12:07h

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.


  


2. Código de como fazer

José Gabriel Gruber
Gruber

(usa Manjaro Linux)

Enviado em 31/08/2017 - 14:45h

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







Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts