Example usage for org.apache.http.entity StringEntity getContentEncoding

List of usage examples for org.apache.http.entity StringEntity getContentEncoding

Introduction

In this page you can find the example usage for org.apache.http.entity StringEntity getContentEncoding.

Prototype

public Header getContentEncoding() 

Source Link

Usage

From source file:com.android.callstat.common.net.ConnectionThread.java

/**
 * A helper method to send or retrieve data through HTTP protocol.
 * /*from www  .j a v  a 2s . c om*/
 * @param token
 *            The token to identify the sending progress.
 * @param url
 *            The URL used in a GET request. Null when the method is
 *            HTTP_POST_METHOD.
 * @param pdu
 *            The data to be POST. Null when the method is HTTP_GET_METHOD.
 * @param method
 *            HTTP_POST_METHOD or HTTP_GET_METHOD.
 * @return A byte array which contains the response data. If an HTTP error
 *         code is returned, an IOException will be thrown.
 * @throws IOException
 *             if any error occurred on network interface or an HTTP error
 *             code(>=400) returned from the server.
 */
private byte[] httpConnection(Context context, boolean isProxySet, MyHttpClient client, String proxyHost,
        int proxyPort, Request request) throws IOException {
    if (request.getUri() == null) {
        throw new IllegalArgumentException("URL must not be null.");
    }
    int timeout = (int) request.getmTimeout();
    if (timeout != 0 && timeout < 5000) {
        timeout = 5000;
    }
    client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, timeout);
    client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, timeout);
    try {
        URI hostUrl = new URI(request.getUri());
        HttpHost target = new HttpHost(hostUrl.getHost(), hostUrl.getPort(), HttpHost.DEFAULT_SCHEME_NAME);
        HttpLog.d("URL:" + request.getUri() + " Host:" + hostUrl.getHost() + " Port:" + hostUrl.getPort());

        HttpRequest req = null;
        switch (request.getMethod()) {
        case HTTP_POST_METHOD:
            HttpPost post = new HttpPost(request.getUri());
            HttpEntity content = request.getHttpEntity();
            if (content != null) {
                post.setEntity(content);
                if (content instanceof StringEntity) {
                    final StringEntity stringEntity = (StringEntity) content;
                    post.setHeader(stringEntity.getContentEncoding());
                    post.setHeader(stringEntity.getContentType());
                }
            }
            req = post;
            break;
        case HTTP_GET_METHOD:
            req = new HttpGet(request.getUri());
            break;
        default:
            HttpLog.e("Unknown HTTP method: " + request.getMethod() + ". Must be one of POST["
                    + HTTP_POST_METHOD + "] or GET[" + HTTP_GET_METHOD + "].");
            return null;
        }
        HttpResponse response = null;
        if (CallStatUtils.isOMS()) {
            setRequest(response, isProxySet, req, client, proxyHost, proxyPort, request);
            response = client.execute(target, req);
        } else {
            if (CallStatUtils.isMOBILE(mContext)) {
                String apn = CallStatUtils.getAPN(mContext);
                if (!StringUtil.isNullOrWhitespaces(apn)) {
                    if (apn.equals("CMWAP")) {
                        HttpClient httpclient = new DefaultHttpClient();
                        HttpHost proxy = new HttpHost("10.0.0.172", 80, "http");
                        httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
                        response = httpclient.execute(target, req);
                    } else {
                        setRequest(response, isProxySet, req, client, proxyHost, proxyPort, request);
                        response = client.execute(target, req);
                    }
                } else {
                    setRequest(response, isProxySet, req, client, proxyHost, proxyPort, request);
                    response = client.execute(target, req);
                }
            } else {
                setRequest(response, isProxySet, req, client, proxyHost, proxyPort, request);
                response = client.execute(target, req);
            }

        }
        StatusLine status = response.getStatusLine();
        request.getEventHandler().status(status.getProtocolVersion().getMajor(),
                status.getProtocolVersion().getMinor(), status.getStatusCode(), status.getReasonPhrase());
        switch (status.getStatusCode()) {
        case 200:
            break;
        case 304:
            request.getEventHandler().endData(null, 0);
            return null;
        default:
            request.getEventHandler().endData(null, 0);
            throw new IOException(
                    "HTTP error: " + status.getReasonPhrase() + " CODE:" + status.getStatusCode());
        }
        Headers headers = new Headers();
        readResponseHeaders(headers, response);
        request.getEventHandler().headers(headers);

        HttpEntity entity = response.getEntity();
        byte[] body = null;
        if (entity != null) {
            try {
                int contentLength = (int) entity.getContentLength();
                if (contentLength > 0) {
                    body = new byte[contentLength];
                    // DataInputStream dis = new
                    // DataInputStream(entity.getContent());
                    InputStream in = entity.getContent();
                    int offset = 0;
                    int length = contentLength;
                    try {
                        while (length > 0) {
                            int result = in.read(body, offset, length);
                            HttpLog.v("################result:" + result);
                            offset += result;
                            length -= result;
                            if (length <= 0) {
                                request.getEventHandler().endData(body, contentLength);
                            }
                        }
                    } finally {
                        try {
                            in.close();
                            // request.mLoadListener.loaded(body,
                            // contentLength);
                            // if(length == 0)
                            // CallbackProxy.getHandler().onFinishResourceLoading(body,
                            // contentLength, request.mLoadListener);
                        } catch (IOException e) {
                            HttpLog.e("Error closing input stream: " + e.getMessage());
                        }
                    }
                } else {
                    ByteArrayBuilder dataBuilder = new ByteArrayBuilder();
                    body = new byte[8192];
                    InputStream in = entity.getContent();
                    int result = 0;
                    int count = 0;
                    int lowWater = body.length / 2;
                    try {
                        while (result != -1) {
                            result = in.read(body, count, body.length - count);
                            if (result != -1) {
                                HttpLog.v("################result:" + result);
                                count += result;
                            }
                            if (result == -1 || count >= lowWater) {
                                dataBuilder.append(body, 0, count);
                                count = 0;
                            }
                            if (result == -1) {
                                if (dataBuilder.getByteSize() > 0) {
                                    byte[] cert = new byte[dataBuilder.getByteSize()];
                                    int offset = 0;
                                    while (true) {
                                        ByteArrayBuilder.Chunk c = dataBuilder.getFirstChunk();
                                        if (c == null)
                                            break;
                                        if (c.mLength != 0) {
                                            System.arraycopy(c.mArray, 0, cert, offset, c.mLength);
                                            offset += c.mLength;
                                        }
                                        c.release();
                                    }
                                    request.getEventHandler().endData(cert, cert.length);
                                }
                            }
                        }
                    } finally {
                        try {
                            in.close();
                        } catch (IOException e) {
                            HttpLog.e("Error closing input stream: " + e.getMessage());
                        }
                    }

                }
            } finally {
                if (entity != null) {
                    entity.consumeContent();
                }
            }
        }
        return body;
    } catch (URISyntaxException e) {
        // TODO Auto-generated catch block
        request.getEventHandler().error(EventHandler.ERROR_BAD_URL, e.getMessage());
        e.printStackTrace();
    } catch (IllegalStateException e) {
        request.getEventHandler().error(EventHandler.ERROR, e.getMessage());
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        request.getEventHandler().error(EventHandler.ERROR_BAD_URL, e.getMessage());
        e.printStackTrace();
    } catch (SocketException e) {
        request.getEventHandler().error(EventHandler.ERROR, e.getMessage());
        e.printStackTrace();
    } catch (ConnectTimeoutException e) {
        request.getEventHandler().error(EventHandler.ERROR_TIMEOUT, e.getMessage());
        e.printStackTrace();
    } catch (Exception e) {
        request.getEventHandler().error(EventHandler.ERROR, e.getMessage());
        e.printStackTrace();
    }
    return null;
}

From source file:com.norman0406.slimgress.API.Interface.Interface.java

public void request(final Handshake handshake, final String requestString, final Location playerLocation,
        final JSONObject requestParams, final RequestResult result) throws InterruptedException {
    if (!handshake.isValid() || handshake.getXSRFToken().length() == 0)
        throw new RuntimeException("handshake is not valid");

    new Thread(new Runnable() {
        public void run() {

            // create post
            String postString = mApiBaseURL + mApiRequest + requestString;
            HttpPost post = new HttpPost(postString);

            // set additional parameters
            JSONObject params = new JSONObject();
            if (requestParams != null) {
                if (requestParams.has("params"))
                    params = requestParams;
                else {
                    try {
                        params.put("params", requestParams);

                        // add persistent request parameters
                        if (playerLocation != null) {
                            String loc = String.format("%08x,%08x", playerLocation.getLatitude(),
                                    playerLocation.getLongitude());
                            params.getJSONObject("params").put("playerLocation", loc);
                            params.getJSONObject("params").put("location", loc);
                        }/*from   www.j  a  va2 s .c om*/
                        params.getJSONObject("params").put("knobSyncTimestamp", getCurrentTimestamp());

                        JSONArray collectedEnergy = new JSONArray();

                        // TODO: add collected energy guids

                        params.getJSONObject("params").put("energyGlobGuids", collectedEnergy);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                try {
                    params.put("params", null);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }

            try {
                StringEntity entity = new StringEntity(params.toString(), "UTF-8");
                entity.setContentType("application/json");
                post.setEntity(entity);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }

            // set header
            post.setHeader("Content-Type", "application/json;charset=UTF-8");
            post.setHeader("Accept-Encoding", "gzip");
            post.setHeader("User-Agent", "Nemesis (gzip)");
            post.setHeader("X-XsrfToken", handshake.getXSRFToken());
            post.setHeader("Host", mApiBase);
            post.setHeader("Connection", "Keep-Alive");
            post.setHeader("Cookie", "SACSID=" + mCookie);

            // execute and get the response.
            try {
                HttpResponse response = null;
                String content = null;

                synchronized (Interface.this) {
                    response = mClient.execute(post);
                    assert (response != null);

                    if (response.getStatusLine().getStatusCode() == 401) {
                        // token expired or similar
                        //isAuthenticated = false;
                        response.getEntity().consumeContent();
                    } else {
                        HttpEntity entity = response.getEntity();

                        // decompress gzip if necessary
                        Header contentEncoding = entity.getContentEncoding();
                        if (contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip"))
                            content = decompressGZIP(entity);
                        else
                            content = EntityUtils.toString(entity);

                        entity.consumeContent();
                    }
                }

                // handle request result
                if (content != null) {
                    JSONObject json = new JSONObject(content);
                    RequestResult.handleRequest(json, result);
                }
            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

From source file:com.google.acre.script.AcreFetch.java

@SuppressWarnings("boxing")
public void fetch(boolean system, String response_encoding, boolean log_to_user, boolean no_redirect) {

    if (request_url.length() > 2047) {
        throw new AcreURLFetchException("fetching URL failed - url is too long");
    }//w  ww  .j av a  2s.co m

    DefaultHttpClient client = new DefaultHttpClient(_connectionManager, null);

    HttpParams params = client.getParams();

    // pass the deadline down to the invoked service.
    // this will be ignored unless we are fetching from another
    // acre server.
    // note that we may send a deadline that is already passed:
    // it's not our job to throw here since we don't know how
    // the target service will interpret the quota header.
    // NOTE: this is done *after* the user sets the headers to overwrite
    // whatever settings they might have tried to change for this value
    // (which could be a security hazard)
    long sub_deadline = (HostEnv.LIMIT_EXECUTION_TIME) ? _deadline - HostEnv.SUBREQUEST_DEADLINE_ADVANCE
            : System.currentTimeMillis() + HostEnv.ACRE_URLFETCH_TIMEOUT;
    int reentries = _reentries + 1;
    request_headers.put(HostEnv.ACRE_QUOTAS_HEADER, "td=" + sub_deadline + ",r=" + reentries);

    // if this is not an internal call, we need to invoke the call thru a proxy
    if (!_internal) {
        // XXX No sense wasting the resources to gzip inside the network.
        // XXX seems that twitter gets upset when we do this
        /*
        if (!request_headers.containsKey("accept-encoding")) {
        request_headers.put("accept-encoding", "gzip");
        }
        */
        String proxy_host = Configuration.Values.HTTP_PROXY_HOST.getValue();
        int proxy_port = -1;
        if (!(proxy_host.length() == 0)) {
            proxy_port = Configuration.Values.HTTP_PROXY_PORT.getInteger();
            HttpHost proxy = new HttpHost(proxy_host, proxy_port, "http");
            params.setParameter(AllClientPNames.DEFAULT_PROXY, proxy);
        }
    }

    params.setParameter(AllClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);

    // in msec

    long timeout = _deadline - System.currentTimeMillis();
    if (timeout < 0)
        timeout = 0;
    params.setParameter(AllClientPNames.CONNECTION_TIMEOUT, (int) timeout);
    params.setParameter(AllClientPNames.SO_TIMEOUT, (int) timeout);

    // we're not streaming the request so this should be a win.
    params.setParameter(AllClientPNames.TCP_NODELAY, true);

    // reuse an existing socket if it is in TIME_WAIT state.
    params.setParameter(AllClientPNames.SO_REUSEADDR, true);

    // set the encoding of our POST payloads to UTF-8
    params.setParameter(AllClientPNames.HTTP_CONTENT_CHARSET, "UTF-8");

    BasicCookieStore cstore = new BasicCookieStore();
    for (AcreCookie cookie : request_cookies.values()) {
        cstore.addCookie(cookie.toClientCookie());
    }
    client.setCookieStore(cstore);

    HttpRequestBase method;

    HashMap<String, String> logmsg = new HashMap<String, String>();
    logmsg.put("Method", request_method);
    logmsg.put("URL", request_url);

    params.setParameter(AllClientPNames.HANDLE_REDIRECTS, !no_redirect);
    logmsg.put("Redirect", Boolean.toString(!no_redirect));

    try {
        if (request_method.equals("GET")) {
            method = new HttpGet(request_url);
        } else if (request_method.equals("POST")) {
            method = new HttpPost(request_url);
        } else if (request_method.equals("HEAD")) {
            method = new HttpHead(request_url);
        } else if (request_method.equals("PUT")) {
            method = new HttpPut(request_url);
        } else if (request_method.equals("DELETE")) {
            method = new HttpDelete(request_url);
        } else if (request_method.equals("PROPFIND")) {
            method = new HttpPropFind(request_url);
        } else {
            throw new AcreURLFetchException("Failed: unsupported (so far) method " + request_method);
        }
        method.getParams().setBooleanParameter(AllClientPNames.USE_EXPECT_CONTINUE, false);
    } catch (java.lang.IllegalArgumentException e) {
        throw new AcreURLFetchException("Unable to fetch URL; this is most likely an issue with URL encoding.");
    } catch (java.lang.IllegalStateException e) {
        throw new AcreURLFetchException("Unable to fetch URL; possibly an illegal protocol?");
    }

    StringBuilder request_header_log = new StringBuilder();
    for (Map.Entry<String, String> header : request_headers.entrySet()) {
        String key = header.getKey();
        String value = header.getValue();

        // XXX should suppress cookie headers?
        // content-type and length?

        if ("content-type".equalsIgnoreCase(key)) {
            Matcher m = contentTypeCharsetPattern.matcher(value);
            if (m.find()) {
                content_type = m.group(1);
                content_type_charset = m.group(2);
            } else {
                content_type_charset = "utf-8";
            }
            method.addHeader(key, value);
        } else if ("content-length".equalsIgnoreCase(key)) {
            // ignore user-supplied content-length, which is
            // probably wrong due to chars vs bytes and is
            // redundant anyway
            ArrayList<String> msg = new ArrayList<String>();
            msg.add("User-supplied content-length header is ignored");
            _acre_response.log("warn", msg);
        } else if ("user-agent".equalsIgnoreCase(key)) {
            params.setParameter(AllClientPNames.USER_AGENT, value);
        } else {
            method.addHeader(key, value);
        }
        if (!("x-acre-auth".equalsIgnoreCase(key))) {
            request_header_log.append(key + ": " + value + "\r\n");
        }
    }
    logmsg.put("Headers", request_header_log.toString());

    // XXX need more detailed error checking
    if (method instanceof HttpEntityEnclosingRequestBase && request_body != null) {

        HttpEntityEnclosingRequestBase em = (HttpEntityEnclosingRequestBase) method;
        try {
            if (request_body instanceof String) {
                StringEntity ent = new StringEntity((String) request_body, content_type_charset);
                em.setEntity(ent);
            } else if (request_body instanceof JSBinary) {
                ByteArrayEntity ent = new ByteArrayEntity(((JSBinary) request_body).get_data());
                em.setEntity(ent);
            }
        } catch (UnsupportedEncodingException e) {
            throw new AcreURLFetchException(
                    "Failed to fetch URL. " + " - Unsupported charset: " + content_type_charset);
        }
    }

    if (!system && log_to_user) {
        ArrayList<Object> msg = new ArrayList<Object>();
        msg.add("urlfetch request");
        msg.add(logmsg);
        _acre_response.log("debug", msg);
    }
    _logger.info("urlfetch.request", logmsg);

    long startTime = System.currentTimeMillis();

    try {
        // this sends the http request and waits
        HttpResponse hres = client.execute(method);
        status = hres.getStatusLine().getStatusCode();
        HashMap<String, String> res_logmsg = new HashMap<String, String>();
        res_logmsg.put("URL", request_url);
        res_logmsg.put("Status", ((Integer) status).toString());

        Header content_type_header = null;

        // translate response headers
        StringBuilder response_header_log = new StringBuilder();
        Header[] rawheaders = hres.getAllHeaders();
        for (Header rawheader : rawheaders) {
            String headername = rawheader.getName().toLowerCase();
            if (headername.equalsIgnoreCase("content-type")) {
                content_type_header = rawheader;
                // XXX should strip everything after ;
                content_type = rawheader.getValue();

                // XXX don't set content_type_parameters, deprecated?
            } else if (headername.equalsIgnoreCase("x-metaweb-cost")) {
                _costCollector.merge(rawheader.getValue());
            } else if (headername.equalsIgnoreCase("x-metaweb-tid")) {
                res_logmsg.put("ITID", rawheader.getValue());
            }

            headers.put(headername, rawheader.getValue());
            response_header_log.append(headername + ": " + rawheader.getValue() + "\r\n");
        }

        res_logmsg.put("Headers", response_header_log.toString());

        if (!system && log_to_user) {
            ArrayList<Object> msg = new ArrayList<Object>();
            msg.add("urlfetch response");
            msg.add(res_logmsg);
            _acre_response.log("debug", msg);
        }

        _logger.info("urlfetch.response", res_logmsg);

        // read cookies
        for (Cookie c : cstore.getCookies()) {
            cookies.put(c.getName(), new AcreCookie(c));
        }

        // get body encoding

        String charset = null;
        if (content_type_header != null) {
            HeaderElement values[] = content_type_header.getElements();
            if (values.length == 1) {
                NameValuePair param = values[0].getParameterByName("charset");
                if (param != null) {
                    charset = param.getValue();
                }
            }
        }

        if (charset == null)
            charset = response_encoding;

        // read body
        HttpEntity ent = hres.getEntity();
        if (ent != null) {
            InputStream res_stream = ent.getContent();
            Header cenc = ent.getContentEncoding();
            if (cenc != null && res_stream != null) {
                HeaderElement[] codecs = cenc.getElements();
                for (HeaderElement codec : codecs) {
                    if (codec.getName().equalsIgnoreCase("gzip")) {
                        res_stream = new GZIPInputStream(res_stream);
                    }
                }
            }

            long firstByteTime = 0;
            long endTime = 0;
            if (content_type != null
                    && (content_type.startsWith("image/") || content_type.startsWith("application/octet-stream")
                            || content_type.startsWith("multipart/form-data"))) {
                // HttpClient's InputStream doesn't support mark/reset, so
                // wrap it with one that does.
                BufferedInputStream bufis = new BufferedInputStream(res_stream);
                bufis.mark(2);
                bufis.read();
                firstByteTime = System.currentTimeMillis();
                bufis.reset();
                byte[] data = IOUtils.toByteArray(bufis);

                endTime = System.currentTimeMillis();
                body = new JSBinary();
                ((JSBinary) body).set_data(data);

                try {
                    if (res_stream != null) {
                        res_stream.close();
                    }
                } catch (IOException e) {
                    // ignore
                }
            } else if (res_stream == null || charset == null) {
                firstByteTime = endTime = System.currentTimeMillis();
                body = "";
            } else {
                StringWriter writer = new StringWriter();
                Reader reader = new InputStreamReader(res_stream, charset);
                int i = reader.read();
                firstByteTime = System.currentTimeMillis();
                writer.write(i);
                IOUtils.copy(reader, writer);
                endTime = System.currentTimeMillis();
                body = writer.toString();

                try {
                    reader.close();
                    writer.close();
                } catch (IOException e) {
                    // ignore
                }
            }

            long waitingTime = firstByteTime - startTime;
            long readingTime = endTime - firstByteTime;

            _logger.debug("urlfetch.timings", "waiting time: " + waitingTime + "ms");
            _logger.debug("urlfetch.timings", "reading time: " + readingTime + "ms");

            Statistics.instance().collectUrlfetchTime(startTime, firstByteTime, endTime);

            _costCollector.collect((system) ? "asuc" : "auuc").collect((system) ? "asuw" : "auuw", waitingTime)
                    .collect((system) ? "asub" : "auub", waitingTime);
        }
    } catch (IllegalArgumentException e) {
        Throwable cause = e.getCause();
        if (cause == null)
            cause = e;
        throw new AcreURLFetchException("failed to fetch URL. " + " - Request Error: " + cause.getMessage());
    } catch (IOException e) {
        Throwable cause = e.getCause();
        if (cause == null)
            cause = e;
        throw new AcreURLFetchException("Failed to fetch URL. " + " - Network Error: " + cause.getMessage());
    } catch (RuntimeException e) {
        Throwable cause = e.getCause();
        if (cause == null)
            cause = e;
        throw new AcreURLFetchException("Failed to fetch URL. " + " - Network Error: " + cause.getMessage());
    } finally {
        method.abort();
    }
}