Android Open Source - androidwisprclient Http Utils

• Back to Network/client  ↑

From Project

Back to project page androidwisprclient.

License

The source code is released under:

GNU General Public License

Java Source Code

/*
 * This file is part of FONAccess.//from  ww w . jav a2s. co m
 * 
 * FONAccess is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * FONAccess is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with FONAccess. If not, see <http://www.gnu.org/licenses/>.
 */
package com.oakley.fon.util;

import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.zip.GZIPInputStream;

import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.HttpEntityWrapper;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import android.util.Log;

public class HttpUtils {
  private static final int DEFAULT_MAX_RETRIES = 3;

  private static String TAG = HttpUtils.class.getName();

  private static final String UTF8 = "UTF-8";

  private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";

  private static final String ENCODING_GZIP = "gzip";

  private static HttpParams defaultHttpParams = new BasicHttpParams();

  static {
    defaultHttpParams.setParameter(CoreProtocolPNames.USER_AGENT, "FONAccess; wispr; (Linux; U; Android)");
  }

  public static HttpResult getUrl(String url) throws IOException {
    return getUrl(url, DEFAULT_MAX_RETRIES);
  }

  public static HttpResult getUrl(String url, int maxRetries) throws IOException {
    String result = null;
    int retries = 0;
    HttpContext localContext = new BasicHttpContext();
    DefaultHttpClient httpclient = getHttpClient();

    HttpGet httpget = new HttpGet(url);
    while (retries <= maxRetries && result == null) {
      try {
        retries++;
        HttpEntity entity = httpclient.execute(httpget, localContext).getEntity();

        if (entity != null) {
          result = EntityUtils.toString(entity).trim();
        }
      } catch (SocketException se) {
        if (retries > maxRetries) {
          throw se;
        } else {
          Log.v(TAG, "SocketException, retrying " + retries);
        }
      }
    }

    return new HttpResult(result, (BasicHttpResponse) localContext.getAttribute("http.response"),
        ((HttpHost) localContext.getAttribute("http.target_host")).toURI());
  }

  public static HttpResult getUrlByPost(String url, Map<String, String> params, int maxRetries) throws IOException {
    return getUrlByPost(url, params, null, maxRetries);
  }

  public static HttpResult getUrlByPost(String url, Map<String, String> params) throws IOException {
    return getUrlByPost(url, params, DEFAULT_MAX_RETRIES);
  }

  public static HttpResult getUrlByPost(String url, Map<String, String> params, Map<String, String> headers,
      int maxRetries) throws IOException {
    String result = null;
    int retries = 0;
    HttpContext localContext = new BasicHttpContext();
    DefaultHttpClient httpclient = getHttpClient();

    List<NameValuePair> formParams = new ArrayList<NameValuePair>();
    if (params != null) {
      Set<Entry<String, String>> paramsSet = params.entrySet();
      for (Entry<String, String> entry : paramsSet) {
        formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
      }
    }

    UrlEncodedFormEntity postEntity = new UrlEncodedFormEntity(formParams, UTF8);
    HttpPost httppost = new HttpPost(url);
    httppost.setEntity(postEntity);

    if (headers != null) {
      Set<Entry<String, String>> headersSet = headers.entrySet();
      for (Entry<String, String> entry : headersSet) {
        httppost.setHeader(entry.getKey(), entry.getValue());
      }
    }

    while (retries < maxRetries && result == null) {
      try {
        retries++;
        HttpEntity responseEntity = httpclient.execute(httppost, localContext).getEntity();
        if (responseEntity != null) {
          result = EntityUtils.toString(responseEntity).trim();
        }
      } catch (SocketException se) {
        if (retries > maxRetries) {
          throw se;
        } else {
          Log.v(TAG, "SocketException, retrying " + retries, se);
        }
      }
    }

    HttpHost attribute = (HttpHost) localContext.getAttribute("http.target_host");
    String targetHost = null;
    if (attribute != null) {
      targetHost = attribute.toURI();
    }

    return new HttpResult(result, (BasicHttpResponse) localContext.getAttribute("http.response"), targetHost);
  }

  public static String getMetaRefresh(String html) {
    String meta = null;
    int start = html.toLowerCase().indexOf("<meta http-equiv=\"refresh\" content=\"");
    if (start > -1) {
      start += 36;

      int end = html.indexOf('"', start);
      if (end > -1) {
        meta = html.substring(start, end);
        start = meta.toLowerCase().indexOf("url=");
        if (start > -1) {
          start += 4;
          meta = new String(meta.substring(start));
        }
      }
    }

    return meta;
  }

  private static DefaultHttpClient getHttpClient() {
    DefaultHttpClient httpclient = new DefaultHttpClient(defaultHttpParams);

    httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
      public void process(HttpRequest request, HttpContext context) {
        if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) {
          request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
        }
      }
    });

    httpclient.addResponseInterceptor(new HttpResponseInterceptor() {
      public void process(HttpResponse response, HttpContext context) {
        // Inflate any responses compressed with gzip
        final HttpEntity entity = response.getEntity();
        final Header encoding = entity.getContentEncoding();
        if (encoding != null) {
          for (HeaderElement element : encoding.getElements()) {
            if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) {
              // Log.d(TAG, "Decompresing GZIP Response");
              response.setEntity(new InflatingEntity(response.getEntity()));
              break;
            }
          }
        }
      }
    });

    httpclient.setCookieStore(null);

    return httpclient;
  }

  /**
   * Simple {@link HttpEntityWrapper} that inflates the wrapped {@link HttpEntity} by passing it
   * through {@link GZIPInputStream}.
   */
  private static class InflatingEntity extends HttpEntityWrapper {
    public InflatingEntity(HttpEntity wrapped) {
      super(wrapped);
    }

    @Override
    public InputStream getContent() throws IOException {
      return new GZIPInputStream(wrappedEntity.getContent());
    }

    @Override
    public long getContentLength() {
      return -1;
    }
  }
}

Java Source Code List

• Back to Network/client  ↑