com.catchnotes.api.VersionedCatchHttpClient.java Source code

Introduction

Here is the source code for com.catchnotes.api.VersionedCatchHttpClient.java

Source

//
//  Copyright 2011 Catch.com, Inc.
//  
//  Licensed 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.
//

package com.catchnotes.api;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLEncoder;

import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.params.HttpClientParams;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;

import android.content.Context;
import android.net.http.AndroidHttpClient;
import android.os.Build;

public abstract class VersionedCatchHttpClient implements HttpClient {
    protected String mEncodedAccessToken;
    protected HttpClient mHttpClient;

    public static VersionedCatchHttpClient newInstance(String userAgent, Context context) {
        VersionedCatchHttpClient client;

        if (Integer.parseInt(Build.VERSION.SDK) < Build.VERSION_CODES.FROYO) {
            client = new PreFroyoCatchHttpClient(userAgent);
        } else {
            client = new CatchHttpClient(userAgent, context);
        }

        return client;
    }

    private static class PreFroyoCatchHttpClient extends VersionedCatchHttpClient {
        public PreFroyoCatchHttpClient(String userAgent) {
            HttpParams params = new BasicHttpParams();
            HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
            HttpProtocolParams.setUserAgent(params, userAgent);
            HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

            // Use some properties set in the default impl of AndroidHttpdClient

            // Turn off stale checking.  Our connections break all the time anyway,
            // and it's not worth it to pay the penalty of checking every time.
            HttpConnectionParams.setStaleCheckingEnabled(params, false);

            // Default connection and socket timeout of 20 seconds.
            HttpConnectionParams.setConnectionTimeout(params, 20000);
            HttpConnectionParams.setSoTimeout(params, 20000);
            HttpConnectionParams.setSocketBufferSize(params, 8192);

            mHttpClient = new DefaultHttpClient(params);
        }
    }

    private static class CatchHttpClient extends VersionedCatchHttpClient {
        public CatchHttpClient(String userAgent, Context context) {
            mHttpClient = AndroidHttpClient.newInstance(userAgent, context);
            HttpParams httpParams = mHttpClient.getParams();
            HttpClientParams.setRedirecting(httpParams, true);
            HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
            HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);
        }

        public void close() {
            ((AndroidHttpClient) mHttpClient).close();
        }
    }

    public void close() {
    }

    public void setAccessToken(String accessToken) {
        try {
            mEncodedAccessToken = "access_token=" + URLEncoder.encode(accessToken, HTTP.UTF_8);
        } catch (UnsupportedEncodingException e) {
            throw new AssertionError(e);
        }
    }

    private void addAccessTokenToHttpUriRequest(HttpUriRequest httpUriRequest) {
        if (mEncodedAccessToken != null) {
            String query = httpUriRequest.getURI().getQuery();

            if (query == null || query.length() == 0) {
                ((HttpRequestBase) httpUriRequest)
                        .setURI(URI.create(httpUriRequest.getURI() + "?" + mEncodedAccessToken));
            } else {
                ((HttpRequestBase) httpUriRequest)
                        .setURI(URI.create(httpUriRequest.getURI() + "&" + mEncodedAccessToken));
            }
        }
    }

    public HttpParams getParams() {
        return mHttpClient.getParams();
    }

    public ClientConnectionManager getConnectionManager() {
        return mHttpClient.getConnectionManager();
    }

    public HttpResponse execute(HttpUriRequest httpUriRequest) throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest(httpUriRequest);
        return mHttpClient.execute(httpUriRequest);
    }

    public HttpResponse execute(HttpUriRequest httpUriRequest, HttpContext httpContext)
            throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest(httpUriRequest);
        return mHttpClient.execute(httpUriRequest, httpContext);
    }

    public HttpResponse execute(HttpHost httpHost, HttpRequest httpRequest)
            throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest((HttpUriRequest) httpRequest);
        return mHttpClient.execute(httpHost, httpRequest);
    }

    public HttpResponse execute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext)
            throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest((HttpUriRequest) httpRequest);
        return mHttpClient.execute(httpHost, httpRequest, httpContext);
    }

    public <T> T execute(HttpUriRequest httpUriRequest, ResponseHandler<? extends T> responseHandler)
            throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest(httpUriRequest);
        return mHttpClient.execute(httpUriRequest, responseHandler);
    }

    public <T> T execute(HttpUriRequest httpUriRequest, ResponseHandler<? extends T> responseHandler,
            HttpContext httpContext) throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest(httpUriRequest);
        return mHttpClient.execute(httpUriRequest, responseHandler, httpContext);
    }

    public <T> T execute(HttpHost httpHost, HttpRequest httpRequest, ResponseHandler<? extends T> responseHandler)
            throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest((HttpUriRequest) httpRequest);
        return mHttpClient.execute(httpHost, httpRequest, responseHandler);
    }

    public <T> T execute(HttpHost httpHost, HttpRequest httpRequest, ResponseHandler<? extends T> responseHandler,
            HttpContext httpContext) throws IOException, ClientProtocolException {
        addAccessTokenToHttpUriRequest((HttpUriRequest) httpRequest);
        return mHttpClient.execute(httpHost, httpRequest, responseHandler, httpContext);
    }
}