diff -r 000000000000 -r 6474c204b198 mobile/android/thirdparty/ch/boye/httpclientandroidlib/util/EntityUtils.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/util/EntityUtils.java Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,224 @@ +/* + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + */ + +package ch.boye.httpclientandroidlib.util; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; + +import ch.boye.httpclientandroidlib.HeaderElement; +import ch.boye.httpclientandroidlib.HttpEntity; +import ch.boye.httpclientandroidlib.NameValuePair; +import ch.boye.httpclientandroidlib.ParseException; +import ch.boye.httpclientandroidlib.protocol.HTTP; + +/** + * Static helpers for dealing with {@link HttpEntity}s. + * + * @since 4.0 + */ +public final class EntityUtils { + + private EntityUtils() { + } + + /** + * Ensures that the entity content is fully consumed and the content stream, if exists, + * is closed. + * + * @param entity + * @throws IOException if an error occurs reading the input stream + * + * @since 4.1 + */ + public static void consume(final HttpEntity entity) throws IOException { + if (entity == null) { + return; + } + if (entity.isStreaming()) { + InputStream instream = entity.getContent(); + if (instream != null) { + instream.close(); + } + } + } + + /** + * Read the contents of an entity and return it as a byte array. + * + * @param entity + * @return byte array containing the entity content. May be null if + * {@link HttpEntity#getContent()} is null. + * @throws IOException if an error occurs reading the input stream + * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE + */ + public static byte[] toByteArray(final HttpEntity entity) throws IOException { + if (entity == null) { + throw new IllegalArgumentException("HTTP entity may not be null"); + } + InputStream instream = entity.getContent(); + if (instream == null) { + return null; + } + try { + if (entity.getContentLength() > Integer.MAX_VALUE) { + throw new IllegalArgumentException("HTTP entity too large to be buffered in memory"); + } + int i = (int)entity.getContentLength(); + if (i < 0) { + i = 4096; + } + ByteArrayBuffer buffer = new ByteArrayBuffer(i); + byte[] tmp = new byte[4096]; + int l; + while((l = instream.read(tmp)) != -1) { + buffer.append(tmp, 0, l); + } + return buffer.toByteArray(); + } finally { + instream.close(); + } + } + + /** + * Obtains character set of the entity, if known. + * + * @param entity must not be null + * @return the character set, or null if not found + * @throws ParseException if header elements cannot be parsed + * @throws IllegalArgumentException if entity is null + */ + public static String getContentCharSet(final HttpEntity entity) throws ParseException { + if (entity == null) { + throw new IllegalArgumentException("HTTP entity may not be null"); + } + String charset = null; + if (entity.getContentType() != null) { + HeaderElement values[] = entity.getContentType().getElements(); + if (values.length > 0) { + NameValuePair param = values[0].getParameterByName("charset"); + if (param != null) { + charset = param.getValue(); + } + } + } + return charset; + } + + /** + * Obtains mime type of the entity, if known. + * + * @param entity must not be null + * @return the character set, or null if not found + * @throws ParseException if header elements cannot be parsed + * @throws IllegalArgumentException if entity is null + * + * @since 4.1 + */ + public static String getContentMimeType(final HttpEntity entity) throws ParseException { + if (entity == null) { + throw new IllegalArgumentException("HTTP entity may not be null"); + } + String mimeType = null; + if (entity.getContentType() != null) { + HeaderElement values[] = entity.getContentType().getElements(); + if (values.length > 0) { + mimeType = values[0].getName(); + } + } + return mimeType; + } + + /** + * Get the entity content as a String, using the provided default character set + * if none is found in the entity. + * If defaultCharset is null, the default "ISO-8859-1" is used. + * + * @param entity must not be null + * @param defaultCharset character set to be applied if none found in the entity + * @return the entity content as a String. May be null if + * {@link HttpEntity#getContent()} is null. + * @throws ParseException if header elements cannot be parsed + * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE + * @throws IOException if an error occurs reading the input stream + */ + public static String toString( + final HttpEntity entity, final String defaultCharset) throws IOException, ParseException { + if (entity == null) { + throw new IllegalArgumentException("HTTP entity may not be null"); + } + InputStream instream = entity.getContent(); + if (instream == null) { + return null; + } + try { + if (entity.getContentLength() > Integer.MAX_VALUE) { + throw new IllegalArgumentException("HTTP entity too large to be buffered in memory"); + } + int i = (int)entity.getContentLength(); + if (i < 0) { + i = 4096; + } + String charset = getContentCharSet(entity); + if (charset == null) { + charset = defaultCharset; + } + if (charset == null) { + charset = HTTP.DEFAULT_CONTENT_CHARSET; + } + Reader reader = new InputStreamReader(instream, charset); + CharArrayBuffer buffer = new CharArrayBuffer(i); + char[] tmp = new char[1024]; + int l; + while((l = reader.read(tmp)) != -1) { + buffer.append(tmp, 0, l); + } + return buffer.toString(); + } finally { + instream.close(); + } + } + + /** + * Read the contents of an entity and return it as a String. + * The content is converted using the character set from the entity (if any), + * failing that, "ISO-8859-1" is used. + * + * @param entity + * @return String containing the content. + * @throws ParseException if header elements cannot be parsed + * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE + * @throws IOException if an error occurs reading the input stream + */ + public static String toString(final HttpEntity entity) + throws IOException, ParseException { + return toString(entity, null); + } + +}