| // Copyright 2008, The Android Open Source Project |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, |
| // this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // 3. Neither the name of Google Inc. nor the names of its contributors may be |
| // used to endorse or promote products derived from this software without |
| // specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package android.webkit.gears; |
| |
| import android.net.http.Headers; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.util.Config; |
| import android.util.Log; |
| import android.webkit.CacheManager; |
| import android.webkit.CacheManager.CacheResult; |
| import android.webkit.CookieManager; |
| |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.IOException; |
| import java.lang.StringBuilder; |
| import java.util.Date; |
| import java.util.Map; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| |
| import org.apache.http.Header; |
| import org.apache.http.HttpEntity; |
| import org.apache.http.client.params.HttpClientParams; |
| import org.apache.http.params.HttpParams; |
| import org.apache.http.params.HttpConnectionParams; |
| import org.apache.http.params.HttpProtocolParams; |
| import org.apache.http.HttpResponse; |
| import org.apache.http.entity.AbstractHttpEntity; |
| import org.apache.http.client.*; |
| import org.apache.http.client.methods.*; |
| import org.apache.http.impl.client.AbstractHttpClient; |
| import org.apache.http.impl.client.DefaultHttpClient; |
| import org.apache.http.impl.client.DefaultHttpRequestRetryHandler; |
| import org.apache.http.conn.ssl.StrictHostnameVerifier; |
| import org.apache.http.impl.cookie.DateUtils; |
| import org.apache.http.util.CharArrayBuffer; |
| |
| import java.util.concurrent.locks.Condition; |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReentrantLock; |
| |
| /** |
| * Performs the underlying HTTP/HTTPS GET, POST, HEAD, PUT, DELETE requests. |
| * <p> These are performed synchronously (blocking). The caller should |
| * ensure that it is in a background thread if asynchronous behavior |
| * is required. All data is pushed, so there is no need for JNI native |
| * callbacks. |
| * <p> This uses Apache's HttpClient framework to perform most |
| * of the underlying network activity. The Android brower's cache, |
| * android.webkit.CacheManager, is also used when caching is enabled, |
| * and updated with new data. The android.webkit.CookieManager is also |
| * queried and updated as necessary. |
| * <p> The public interface is designed to be called by native code |
| * through JNI, and to simplify coding none of the public methods will |
| * surface a checked exception. Unchecked exceptions may still be |
| * raised but only if the system is in an ill state, such as out of |
| * memory. |
| * <p> TODO: This isn't plumbed into LocalServer yet. Mutually |
| * dependent on LocalServer - will attach the two together once both |
| * are submitted. |
| */ |
| public final class ApacheHttpRequestAndroid { |
| /** Debug logging tag. */ |
| private static final String LOG_TAG = "Gears-J"; |
| /** HTTP response header line endings are CR-LF style. */ |
| private static final String HTTP_LINE_ENDING = "\r\n"; |
| /** Safe MIME type to use whenever it isn't specified. */ |
| private static final String DEFAULT_MIME_TYPE = "text/plain"; |
| /** Case-sensitive header keys */ |
| public static final String KEY_CONTENT_LENGTH = "Content-Length"; |
| public static final String KEY_EXPIRES = "Expires"; |
| public static final String KEY_LAST_MODIFIED = "Last-Modified"; |
| public static final String KEY_ETAG = "ETag"; |
| public static final String KEY_LOCATION = "Location"; |
| public static final String KEY_CONTENT_TYPE = "Content-Type"; |
| /** Number of bytes to send and receive on the HTTP connection in |
| * one go. */ |
| private static final int BUFFER_SIZE = 4096; |
| |
| /** The first element of the String[] value in a headers map is the |
| * unmodified (case-sensitive) key. */ |
| public static final int HEADERS_MAP_INDEX_KEY = 0; |
| /** The second element of the String[] value in a headers map is the |
| * associated value. */ |
| public static final int HEADERS_MAP_INDEX_VALUE = 1; |
| |
| /** Request headers, as key -> value map. */ |
| // TODO: replace this design by a simpler one (the C++ side has to |
| // be modified too), where we do not store both the original header |
| // and the lowercase one. |
| private Map<String, String[]> mRequestHeaders = |
| new HashMap<String, String[]>(); |
| /** Response headers, as a lowercase key -> value map. */ |
| private Map<String, String[]> mResponseHeaders = |
| new HashMap<String, String[]>(); |
| /** The URL used for createCacheResult() */ |
| private String mCacheResultUrl; |
| /** CacheResult being saved into, if inserting a new cache entry. */ |
| private CacheResult mCacheResult; |
| /** Initialized by initChildThread(). Used to target abort(). */ |
| private Thread mBridgeThread; |
| |
| /** Our HttpClient */ |
| private AbstractHttpClient mClient; |
| /** The HttpMethod associated with this request */ |
| private HttpRequestBase mMethod; |
| /** The complete response line e.g "HTTP/1.0 200 OK" */ |
| private String mResponseLine; |
| /** HTTP body stream, setup after connection. */ |
| private InputStream mBodyInputStream; |
| |
| /** HTTP Response Entity */ |
| private HttpResponse mResponse; |
| |
| /** Post Entity, used to stream the request to the server */ |
| private StreamEntity mPostEntity = null; |
| /** Content lenght, mandatory when using POST */ |
| private long mContentLength; |
| |
| /** The request executes in a parallel thread */ |
| private Thread mHttpThread = null; |
| /** protect mHttpThread, if interrupt() is called concurrently */ |
| private Lock mHttpThreadLock = new ReentrantLock(); |
| /** Flag set to true when the request thread is joined */ |
| private boolean mConnectionFinished = false; |
| /** Flag set to true by interrupt() and/or connection errors */ |
| private boolean mConnectionFailed = false; |
| /** Lock protecting the access to mConnectionFailed */ |
| private Lock mConnectionFailedLock = new ReentrantLock(); |
| |
| /** Lock on the loop in StreamEntity */ |
| private Lock mStreamingReadyLock = new ReentrantLock(); |
| /** Condition variable used to signal the loop is ready... */ |
| private Condition mStreamingReady = mStreamingReadyLock.newCondition(); |
| |
| /** Used to pass around the block of data POSTed */ |
| private Buffer mBuffer = new Buffer(); |
| /** Used to signal that the block of data has been written */ |
| private SignalConsumed mSignal = new SignalConsumed(); |
| |
| // inner classes |
| |
| /** |
| * Implements the http request |
| */ |
| class Connection implements Runnable { |
| public void run() { |
| boolean problem = false; |
| try { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "REQUEST : " + mMethod.getRequestLine()); |
| } |
| mResponse = mClient.execute(mMethod); |
| if (mResponse != null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "response (status line): " |
| + mResponse.getStatusLine()); |
| } |
| mResponseLine = "" + mResponse.getStatusLine(); |
| } else { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "problem, response == null"); |
| } |
| problem = true; |
| } |
| } catch (IOException e) { |
| Log.e(LOG_TAG, "Connection IO exception ", e); |
| problem = true; |
| } catch (RuntimeException e) { |
| Log.e(LOG_TAG, "Connection runtime exception ", e); |
| problem = true; |
| } |
| |
| if (!problem) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Request complete (" |
| + mMethod.getRequestLine() + ")"); |
| } |
| } else { |
| mConnectionFailedLock.lock(); |
| mConnectionFailed = true; |
| mConnectionFailedLock.unlock(); |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Request FAILED (" |
| + mMethod.getRequestLine() + ")"); |
| } |
| // We abort the execution in order to shutdown and release |
| // the underlying connection |
| mMethod.abort(); |
| if (mPostEntity != null) { |
| // If there is a post entity, we need to wake it up from |
| // a potential deadlock |
| mPostEntity.signalOutputStream(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * simple buffer class implementing a producer/consumer model |
| */ |
| class Buffer { |
| private DataPacket mPacket; |
| private boolean mEmpty = true; |
| public synchronized void put(DataPacket packet) { |
| while (!mEmpty) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "InterruptedException while putting " + |
| "a DataPacket in the Buffer: " + e); |
| } |
| } |
| } |
| mPacket = packet; |
| mEmpty = false; |
| notify(); |
| } |
| public synchronized DataPacket get() { |
| while (mEmpty) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "InterruptedException while getting " + |
| "a DataPacket in the Buffer: " + e); |
| } |
| } |
| } |
| mEmpty = true; |
| notify(); |
| return mPacket; |
| } |
| } |
| |
| /** |
| * utility class used to block until the packet is signaled as being |
| * consumed |
| */ |
| class SignalConsumed { |
| private boolean mConsumed = false; |
| public synchronized void waitUntilPacketConsumed() { |
| while (!mConsumed) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "InterruptedException while waiting " + |
| "until a DataPacket is consumed: " + e); |
| } |
| } |
| } |
| mConsumed = false; |
| notify(); |
| } |
| public synchronized void packetConsumed() { |
| while (mConsumed) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "InterruptedException while indicating " |
| + "that the DataPacket has been consumed: " + e); |
| } |
| } |
| } |
| mConsumed = true; |
| notify(); |
| } |
| } |
| |
| /** |
| * Utility class encapsulating a packet of data |
| */ |
| class DataPacket { |
| private byte[] mContent; |
| private int mLength; |
| public DataPacket(byte[] content, int length) { |
| mContent = content; |
| mLength = length; |
| } |
| public byte[] getBytes() { |
| return mContent; |
| } |
| public int getLength() { |
| return mLength; |
| } |
| } |
| |
| /** |
| * HttpEntity class to write the bytes received by the C++ thread |
| * on the connection outputstream, in a streaming way. |
| * This entity is executed in the request thread. |
| * The writeTo() method is automatically called by the |
| * HttpPost execution; upon reception, we loop while receiving |
| * the data packets from the main thread, until completion |
| * or error. When done, we flush the outputstream. |
| * The main thread (sendPostData()) also blocks until the |
| * outputstream is made available (or an error happens) |
| */ |
| class StreamEntity implements HttpEntity { |
| private OutputStream mOutputStream; |
| |
| // HttpEntity interface methods |
| |
| public boolean isRepeatable() { |
| return false; |
| } |
| |
| public boolean isChunked() { |
| return false; |
| } |
| |
| public long getContentLength() { |
| return mContentLength; |
| } |
| |
| public Header getContentType() { |
| return null; |
| } |
| |
| public Header getContentEncoding() { |
| return null; |
| } |
| |
| public InputStream getContent() throws IOException { |
| return null; |
| } |
| |
| public void writeTo(final OutputStream out) throws IOException { |
| // We signal that the outputstream is available |
| mStreamingReadyLock.lock(); |
| mOutputStream = out; |
| mStreamingReady.signal(); |
| mStreamingReadyLock.unlock(); |
| |
| // We then loop waiting on messages to process. |
| boolean finished = false; |
| while (!finished) { |
| DataPacket packet = mBuffer.get(); |
| if (packet == null) { |
| finished = true; |
| } else { |
| write(packet); |
| } |
| mSignal.packetConsumed(); |
| mConnectionFailedLock.lock(); |
| if (mConnectionFailed) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "stopping loop on error"); |
| } |
| finished = true; |
| } |
| mConnectionFailedLock.unlock(); |
| } |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "flushing the outputstream..."); |
| } |
| mOutputStream.flush(); |
| } |
| |
| public boolean isStreaming() { |
| return true; |
| } |
| |
| public void consumeContent() throws IOException { |
| // Nothing to release |
| } |
| |
| // local methods |
| |
| private void write(DataPacket packet) { |
| try { |
| if (mOutputStream == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "NO OUTPUT STREAM !!!"); |
| } |
| return; |
| } |
| mOutputStream.write(packet.getBytes(), 0, packet.getLength()); |
| mOutputStream.flush(); |
| } catch (IOException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "exc: " + e); |
| } |
| mConnectionFailedLock.lock(); |
| mConnectionFailed = true; |
| mConnectionFailedLock.unlock(); |
| } |
| } |
| |
| public boolean isReady() { |
| mStreamingReadyLock.lock(); |
| try { |
| if (mOutputStream == null) { |
| mStreamingReady.await(); |
| } |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "InterruptedException in " |
| + "StreamEntity::isReady() : ", e); |
| } |
| } finally { |
| mStreamingReadyLock.unlock(); |
| } |
| if (mOutputStream == null) { |
| return false; |
| } |
| return true; |
| } |
| |
| public void signalOutputStream() { |
| mStreamingReadyLock.lock(); |
| mStreamingReady.signal(); |
| mStreamingReadyLock.unlock(); |
| } |
| } |
| |
| /** |
| * Initialize mBridgeThread using the TLS value of |
| * Thread.currentThread(). Called on start up of the native child |
| * thread. |
| */ |
| public synchronized void initChildThread() { |
| mBridgeThread = Thread.currentThread(); |
| } |
| |
| public void setContentLength(long length) { |
| mContentLength = length; |
| } |
| |
| /** |
| * Analagous to the native-side HttpRequest::open() function. This |
| * initializes an underlying HttpClient method, but does |
| * not go to the wire. On success, this enables a call to send() to |
| * initiate the transaction. |
| * |
| * @param method The HTTP method, e.g GET or POST. |
| * @param url The URL to open. |
| * @return True on success with a complete HTTP response. |
| * False on failure. |
| */ |
| public synchronized boolean open(String method, String url) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "open " + method + " " + url); |
| } |
| // Create the client |
| if (mConnectionFailed) { |
| // interrupt() could have been called even before open() |
| return false; |
| } |
| mClient = new DefaultHttpClient(); |
| mClient.setHttpRequestRetryHandler( |
| new DefaultHttpRequestRetryHandler(0, false)); |
| mBodyInputStream = null; |
| mResponseLine = null; |
| mResponseHeaders = null; |
| mPostEntity = null; |
| mHttpThread = null; |
| mConnectionFailed = false; |
| mConnectionFinished = false; |
| |
| // Create the method. We support everything that |
| // Apache HttpClient supports, apart from TRACE. |
| if ("GET".equalsIgnoreCase(method)) { |
| mMethod = new HttpGet(url); |
| } else if ("POST".equalsIgnoreCase(method)) { |
| mMethod = new HttpPost(url); |
| mPostEntity = new StreamEntity(); |
| ((HttpPost)mMethod).setEntity(mPostEntity); |
| } else if ("HEAD".equalsIgnoreCase(method)) { |
| mMethod = new HttpHead(url); |
| } else if ("PUT".equalsIgnoreCase(method)) { |
| mMethod = new HttpPut(url); |
| } else if ("DELETE".equalsIgnoreCase(method)) { |
| mMethod = new HttpDelete(url); |
| } else { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Method " + method + " not supported"); |
| } |
| return false; |
| } |
| HttpParams params = mClient.getParams(); |
| // We handle the redirections C++-side |
| HttpClientParams.setRedirecting(params, false); |
| HttpProtocolParams.setUseExpectContinue(params, false); |
| return true; |
| } |
| |
| /** |
| * We use this to start the connection thread (doing the method execute). |
| * We usually always return true here, as the connection will run its |
| * course in the thread. |
| * We only return false if interrupted beforehand -- if a connection |
| * problem happens, we will thus fail in either sendPostData() or |
| * parseHeaders(). |
| */ |
| public synchronized boolean connectToRemote() { |
| boolean ret = false; |
| applyRequestHeaders(); |
| mConnectionFailedLock.lock(); |
| if (!mConnectionFailed) { |
| mHttpThread = new Thread(new Connection()); |
| mHttpThread.start(); |
| } |
| ret = mConnectionFailed; |
| mConnectionFailedLock.unlock(); |
| return !ret; |
| } |
| |
| /** |
| * Get the complete response line of the HTTP request. Only valid on |
| * completion of the transaction. |
| * @return The complete HTTP response line, e.g "HTTP/1.0 200 OK". |
| */ |
| public synchronized String getResponseLine() { |
| return mResponseLine; |
| } |
| |
| /** |
| * Wait for the request thread completion |
| * (unless already finished) |
| */ |
| private void waitUntilConnectionFinished() { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "waitUntilConnectionFinished(" |
| + mConnectionFinished + ")"); |
| } |
| if (!mConnectionFinished) { |
| if (mHttpThread != null) { |
| try { |
| mHttpThread.join(); |
| mConnectionFinished = true; |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "http thread joined"); |
| } |
| } catch (InterruptedException e) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "interrupted: " + e); |
| } |
| } |
| } else { |
| Log.e(LOG_TAG, ">>> Trying to join on mHttpThread " + |
| "when it does not exist!"); |
| } |
| } |
| } |
| |
| // Headers handling |
| |
| /** |
| * Receive all headers from the server and populate |
| * mResponseHeaders. |
| * @return True if headers are successfully received, False on |
| * connection error. |
| */ |
| public synchronized boolean parseHeaders() { |
| mConnectionFailedLock.lock(); |
| if (mConnectionFailed) { |
| mConnectionFailedLock.unlock(); |
| return false; |
| } |
| mConnectionFailedLock.unlock(); |
| waitUntilConnectionFinished(); |
| mResponseHeaders = new HashMap<String, String[]>(); |
| if (mResponse == null) |
| return false; |
| |
| Header[] headers = mResponse.getAllHeaders(); |
| for (int i = 0; i < headers.length; i++) { |
| Header header = headers[i]; |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "header " + header.getName() |
| + " -> " + header.getValue()); |
| } |
| setResponseHeader(header.getName(), header.getValue()); |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Set a header to send with the HTTP request. Will not take effect |
| * on a transaction already in progress. The key is associated |
| * case-insensitive, but stored case-sensitive. |
| * @param name The name of the header, e.g "Set-Cookie". |
| * @param value The value for this header, e.g "text/html". |
| */ |
| public synchronized void setRequestHeader(String name, String value) { |
| String[] mapValue = { name, value }; |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "setRequestHeader: " + name + " => " + value); |
| } |
| if (name.equalsIgnoreCase(KEY_CONTENT_LENGTH)) { |
| setContentLength(Long.parseLong(value)); |
| } else { |
| mRequestHeaders.put(name.toLowerCase(), mapValue); |
| } |
| } |
| |
| /** |
| * Returns the value associated with the given request header. |
| * @param name The name of the request header, non-null, case-insensitive. |
| * @return The value associated with the request header, or null if |
| * not set, or error. |
| */ |
| public synchronized String getRequestHeader(String name) { |
| String[] value = mRequestHeaders.get(name.toLowerCase()); |
| if (value != null) { |
| return value[HEADERS_MAP_INDEX_VALUE]; |
| } else { |
| return null; |
| } |
| } |
| |
| private void applyRequestHeaders() { |
| if (mMethod == null) |
| return; |
| Iterator<String[]> it = mRequestHeaders.values().iterator(); |
| while (it.hasNext()) { |
| // Set the key case-sensitive. |
| String[] entry = it.next(); |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "apply header " + entry[HEADERS_MAP_INDEX_KEY] + |
| " => " + entry[HEADERS_MAP_INDEX_VALUE]); |
| } |
| mMethod.setHeader(entry[HEADERS_MAP_INDEX_KEY], |
| entry[HEADERS_MAP_INDEX_VALUE]); |
| } |
| } |
| |
| /** |
| * Returns the value associated with the given response header. |
| * @param name The name of the response header, non-null, case-insensitive. |
| * @return The value associated with the response header, or null if |
| * not set or error. |
| */ |
| public synchronized String getResponseHeader(String name) { |
| if (mResponseHeaders != null) { |
| String[] value = mResponseHeaders.get(name.toLowerCase()); |
| if (value != null) { |
| return value[HEADERS_MAP_INDEX_VALUE]; |
| } else { |
| return null; |
| } |
| } else { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "getResponseHeader() called but " |
| + "response not received"); |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * Return all response headers, separated by CR-LF line endings, and |
| * ending with a trailing blank line. This mimics the format of the |
| * raw response header up to but not including the body. |
| * @return A string containing the entire response header. |
| */ |
| public synchronized String getAllResponseHeaders() { |
| if (mResponseHeaders == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "getAllResponseHeaders() called but " |
| + "response not received"); |
| } |
| return null; |
| } |
| StringBuilder result = new StringBuilder(); |
| Iterator<String[]> it = mResponseHeaders.values().iterator(); |
| while (it.hasNext()) { |
| String[] entry = it.next(); |
| // Output the "key: value" lines. |
| result.append(entry[HEADERS_MAP_INDEX_KEY]); |
| result.append(": "); |
| result.append(entry[HEADERS_MAP_INDEX_VALUE]); |
| result.append(HTTP_LINE_ENDING); |
| } |
| result.append(HTTP_LINE_ENDING); |
| return result.toString(); |
| } |
| |
| |
| /** |
| * Set a response header and associated value. The key is associated |
| * case-insensitively, but stored case-sensitively. |
| * @param name Case sensitive request header key. |
| * @param value The associated value. |
| */ |
| private void setResponseHeader(String name, String value) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Set response header " + name + ": " + value); |
| } |
| String mapValue[] = { name, value }; |
| mResponseHeaders.put(name.toLowerCase(), mapValue); |
| } |
| |
| // Cookie handling |
| |
| /** |
| * Get the cookie for the given URL. |
| * @param url The fully qualified URL. |
| * @return A string containing the cookie for the URL if it exists, |
| * or null if not. |
| */ |
| public static String getCookieForUrl(String url) { |
| // Get the cookie for this URL, set as a header |
| return CookieManager.getInstance().getCookie(url); |
| } |
| |
| /** |
| * Set the cookie for the given URL. |
| * @param url The fully qualified URL. |
| * @param cookie The new cookie value. |
| * @return A string containing the cookie for the URL if it exists, |
| * or null if not. |
| */ |
| public static void setCookieForUrl(String url, String cookie) { |
| // Get the cookie for this URL, set as a header |
| CookieManager.getInstance().setCookie(url, cookie); |
| } |
| |
| // Cache handling |
| |
| /** |
| * Perform a request using LocalServer if possible. Initializes |
| * class members so that receive() will obtain data from the stream |
| * provided by the response. |
| * @param url The fully qualified URL to try in LocalServer. |
| * @return True if the url was found and is now setup to receive. |
| * False if not found, with no side-effect. |
| */ |
| public synchronized boolean useLocalServerResult(String url) { |
| UrlInterceptHandlerGears handler = |
| UrlInterceptHandlerGears.getInstance(); |
| if (handler == null) { |
| return false; |
| } |
| UrlInterceptHandlerGears.ServiceResponse serviceResponse = |
| handler.getServiceResponse(url, mRequestHeaders); |
| if (serviceResponse == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "No response in LocalServer"); |
| } |
| return false; |
| } |
| // LocalServer will handle this URL. Initialize stream and |
| // response. |
| mBodyInputStream = serviceResponse.getInputStream(); |
| mResponseLine = serviceResponse.getStatusLine(); |
| mResponseHeaders = serviceResponse.getResponseHeaders(); |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Got response from LocalServer: " + mResponseLine); |
| } |
| return true; |
| } |
| |
| /** |
| * Perform a request using the cache result if present. Initializes |
| * class members so that receive() will obtain data from the cache. |
| * @param url The fully qualified URL to try in the cache. |
| * @return True is the url was found and is now setup to receive |
| * from cache. False if not found, with no side-effect. |
| */ |
| public synchronized boolean useCacheResult(String url) { |
| // Try the browser's cache. CacheManager wants a Map<String, String>. |
| Map<String, String> cacheRequestHeaders = new HashMap<String, String>(); |
| Iterator<Map.Entry<String, String[]>> it = |
| mRequestHeaders.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry<String, String[]> entry = it.next(); |
| cacheRequestHeaders.put( |
| entry.getKey(), |
| entry.getValue()[HEADERS_MAP_INDEX_VALUE]); |
| } |
| CacheResult mCacheResult = |
| CacheManager.getCacheFile(url, cacheRequestHeaders); |
| if (mCacheResult == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "No CacheResult for " + url); |
| } |
| return false; |
| } |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Got CacheResult from browser cache"); |
| } |
| // Check for expiry. -1 is "never", otherwise milliseconds since 1970. |
| // Can be compared to System.currentTimeMillis(). |
| long expires = mCacheResult.getExpires(); |
| if (expires >= 0 && System.currentTimeMillis() >= expires) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "CacheResult expired " |
| + (System.currentTimeMillis() - expires) |
| + " milliseconds ago"); |
| } |
| // Cache hit has expired. Do not return it. |
| return false; |
| } |
| // Setup the mBodyInputStream to come from the cache. |
| mBodyInputStream = mCacheResult.getInputStream(); |
| if (mBodyInputStream == null) { |
| // Cache result may have gone away. |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "No mBodyInputStream for CacheResult " + url); |
| } |
| return false; |
| } |
| // Cache hit. Parse headers. |
| synthesizeHeadersFromCacheResult(mCacheResult); |
| return true; |
| } |
| |
| /** |
| * Take the limited set of headers in a CacheResult and synthesize |
| * response headers. |
| * @param cacheResult A CacheResult to populate mResponseHeaders with. |
| */ |
| private void synthesizeHeadersFromCacheResult(CacheResult cacheResult) { |
| int statusCode = cacheResult.getHttpStatusCode(); |
| // The status message is informal, so we can greatly simplify it. |
| String statusMessage; |
| if (statusCode >= 200 && statusCode < 300) { |
| statusMessage = "OK"; |
| } else if (statusCode >= 300 && statusCode < 400) { |
| statusMessage = "MOVED"; |
| } else { |
| statusMessage = "UNAVAILABLE"; |
| } |
| // Synthesize the response line. |
| mResponseLine = "HTTP/1.1 " + statusCode + " " + statusMessage; |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Synthesized " + mResponseLine); |
| } |
| // Synthesize the returned headers from cache. |
| mResponseHeaders = new HashMap<String, String[]>(); |
| String contentLength = Long.toString(cacheResult.getContentLength()); |
| setResponseHeader(KEY_CONTENT_LENGTH, contentLength); |
| long expires = cacheResult.getExpires(); |
| if (expires >= 0) { |
| // "Expires" header is valid and finite. Milliseconds since 1970 |
| // epoch, formatted as RFC-1123. |
| String expiresString = DateUtils.formatDate(new Date(expires)); |
| setResponseHeader(KEY_EXPIRES, expiresString); |
| } |
| String lastModified = cacheResult.getLastModified(); |
| if (lastModified != null) { |
| // Last modification time of the page. Passed end-to-end, but |
| // not used by us. |
| setResponseHeader(KEY_LAST_MODIFIED, lastModified); |
| } |
| String eTag = cacheResult.getETag(); |
| if (eTag != null) { |
| // Entity tag. A kind of GUID to identify identical resources. |
| setResponseHeader(KEY_ETAG, eTag); |
| } |
| String location = cacheResult.getLocation(); |
| if (location != null) { |
| // If valid, refers to the location of a redirect. |
| setResponseHeader(KEY_LOCATION, location); |
| } |
| String mimeType = cacheResult.getMimeType(); |
| if (mimeType == null) { |
| // Use a safe default MIME type when none is |
| // specified. "text/plain" is safe to render in the browser |
| // window (even if large) and won't be intepreted as anything |
| // that would cause execution. |
| mimeType = DEFAULT_MIME_TYPE; |
| } |
| String encoding = cacheResult.getEncoding(); |
| // Encoding may not be specified. No default. |
| String contentType = mimeType; |
| if (encoding != null) { |
| if (encoding.length() > 0) { |
| contentType += "; charset=" + encoding; |
| } |
| } |
| setResponseHeader(KEY_CONTENT_TYPE, contentType); |
| } |
| |
| /** |
| * Create a CacheResult for this URL. This enables the repsonse body |
| * to be sent in calls to appendCacheResult(). |
| * @param url The fully qualified URL to add to the cache. |
| * @param responseCode The response code returned for the request, e.g 200. |
| * @param mimeType The MIME type of the body, e.g "text/plain". |
| * @param encoding The encoding, e.g "utf-8". Use "" for unknown. |
| */ |
| public synchronized boolean createCacheResult( |
| String url, int responseCode, String mimeType, String encoding) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Making cache entry for " + url); |
| } |
| // Take the headers and parse them into a format needed by |
| // CacheManager. |
| Headers cacheHeaders = new Headers(); |
| Iterator<Map.Entry<String, String[]>> it = |
| mResponseHeaders.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry<String, String[]> entry = it.next(); |
| // Headers.parseHeader() expects lowercase keys. |
| String keyValue = entry.getKey() + ": " |
| + entry.getValue()[HEADERS_MAP_INDEX_VALUE]; |
| CharArrayBuffer buffer = new CharArrayBuffer(keyValue.length()); |
| buffer.append(keyValue); |
| // Parse it into the header container. |
| cacheHeaders.parseHeader(buffer); |
| } |
| mCacheResult = CacheManager.createCacheFile( |
| url, responseCode, cacheHeaders, mimeType, true); |
| if (mCacheResult != null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Saving into cache"); |
| } |
| mCacheResult.setEncoding(encoding); |
| mCacheResultUrl = url; |
| return true; |
| } else { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Couldn't create mCacheResult"); |
| } |
| return false; |
| } |
| } |
| |
| /** |
| * Add data from the response body to the CacheResult created with |
| * createCacheResult(). |
| * @param data A byte array of the next sequential bytes in the |
| * response body. |
| * @param bytes The number of bytes to write from the start of |
| * the array. |
| * @return True if all bytes successfully written, false on failure. |
| */ |
| public synchronized boolean appendCacheResult(byte[] data, int bytes) { |
| if (mCacheResult == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "appendCacheResult() called without a " |
| + "CacheResult initialized"); |
| } |
| return false; |
| } |
| try { |
| mCacheResult.getOutputStream().write(data, 0, bytes); |
| } catch (IOException ex) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Got IOException writing cache data: " + ex); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Save the completed CacheResult into the CacheManager. This must |
| * have been created first with createCacheResult(). |
| * @return Returns true if the entry has been successfully saved. |
| */ |
| public synchronized boolean saveCacheResult() { |
| if (mCacheResult == null || mCacheResultUrl == null) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Tried to save cache result but " |
| + "createCacheResult not called"); |
| } |
| return false; |
| } |
| |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Saving cache result"); |
| } |
| CacheManager.saveCacheFile(mCacheResultUrl, mCacheResult); |
| mCacheResult = null; |
| mCacheResultUrl = null; |
| return true; |
| } |
| |
| /** |
| * Called by the main thread to interrupt the child thread. |
| * We do not set mConnectionFailed here as we still need the |
| * ability to receive a null packet for sendPostData(). |
| */ |
| public synchronized void abort() { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "ABORT CALLED"); |
| } |
| if (mMethod != null) { |
| mMethod.abort(); |
| } |
| } |
| |
| /** |
| * Interrupt a blocking IO operation and wait for the |
| * thread to complete. |
| */ |
| public synchronized void interrupt() { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "INTERRUPT CALLED"); |
| } |
| mConnectionFailedLock.lock(); |
| mConnectionFailed = true; |
| mConnectionFailedLock.unlock(); |
| if (mMethod != null) { |
| mMethod.abort(); |
| } |
| if (mHttpThread != null) { |
| waitUntilConnectionFinished(); |
| } |
| } |
| |
| /** |
| * Receive the next sequential bytes of the response body after |
| * successful connection. This will receive up to the size of the |
| * provided byte array. If there is no body, this will return 0 |
| * bytes on the first call after connection. |
| * @param buf A pre-allocated byte array to receive data into. |
| * @return The number of bytes from the start of the array which |
| * have been filled, 0 on EOF, or negative on error. |
| */ |
| public synchronized int receive(byte[] buf) { |
| if (mBodyInputStream == null) { |
| // If this is the first call, setup the InputStream. This may |
| // fail if there were headers, but no body returned by the |
| // server. |
| try { |
| if (mResponse != null) { |
| HttpEntity entity = mResponse.getEntity(); |
| mBodyInputStream = entity.getContent(); |
| } |
| } catch (IOException inputException) { |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Failed to connect InputStream: " |
| + inputException); |
| } |
| // Not unexpected. For example, 404 response return headers, |
| // and sometimes a body with a detailed error. |
| } |
| if (mBodyInputStream == null) { |
| // No error stream either. Treat as a 0 byte response. |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "No InputStream"); |
| } |
| return 0; // EOF. |
| } |
| } |
| int ret; |
| try { |
| int got = mBodyInputStream.read(buf); |
| if (got > 0) { |
| // Got some bytes, not EOF. |
| ret = got; |
| } else { |
| // EOF. |
| mBodyInputStream.close(); |
| ret = 0; |
| } |
| } catch (IOException e) { |
| // An abort() interrupts us by calling close() on our stream. |
| if (Config.LOGV) { |
| Log.i(LOG_TAG, "Got IOException in mBodyInputStream.read(): ", e); |
| } |
| ret = -1; |
| } |
| return ret; |
| } |
| |
| /** |
| * For POST method requests, send a stream of data provided by the |
| * native side in repeated callbacks. |
| * We put the data in mBuffer, and wait until it is consumed |
| * by the StreamEntity in the request thread. |
| * @param data A byte array containing the data to sent, or null |
| * if indicating EOF. |
| * @param bytes The number of bytes from the start of the array to |
| * send, or 0 if indicating EOF. |
| * @return True if all bytes were successfully sent, false on error. |
| */ |
| public boolean sendPostData(byte[] data, int bytes) { |
| mConnectionFailedLock.lock(); |
| if (mConnectionFailed) { |
| mConnectionFailedLock.unlock(); |
| return false; |
| } |
| mConnectionFailedLock.unlock(); |
| if (mPostEntity == null) return false; |
| |
| // We block until the outputstream is available |
| // (or in case of connection error) |
| if (!mPostEntity.isReady()) return false; |
| |
| if (data == null && bytes == 0) { |
| mBuffer.put(null); |
| } else { |
| mBuffer.put(new DataPacket(data, bytes)); |
| } |
| mSignal.waitUntilPacketConsumed(); |
| |
| mConnectionFailedLock.lock(); |
| if (mConnectionFailed) { |
| Log.e(LOG_TAG, "failure"); |
| mConnectionFailedLock.unlock(); |
| return false; |
| } |
| mConnectionFailedLock.unlock(); |
| return true; |
| } |
| |
| } |
