Proyectos de Subversion Android Microlearning

package com.cesams.twogetskills.library;

import android.util.Log;

import com.cesams.twogetskills.Constants;

import java.io.File;
import java.io.IOException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import okhttp3.Cache;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;

public class Http {
   public final static int CACHE_SIZE = 100 * 1024 * 1024; // 100MB
    private final static String SSL = "SSL";
    private File mCacheDir;
    private String mDeviceUuid;
    private String mSecret;
    private int mCreated;
    private int mRand;
    private boolean mUsingHeaderInterceptor;

    public Http(File cacheDir)
    {
        mDeviceUuid = "";
        mSecret = "";
        mCreated = 0;
        mRand = 0;
        mCacheDir = cacheDir;
    }

    public Http(File cacheDir, String deviceUuid, String secret, int created, int rand)
    {
        mDeviceUuid = deviceUuid;
        mSecret = secret;
        mCreated = created;
        mRand = rand;
        mUsingHeaderInterceptor = true;
        mCacheDir = cacheDir;
    }


    public OkHttpClient getHttpClient(boolean usingCache) throws Exception
    {
        Interceptor headerInterceptor = null;

        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BASIC);

        if(mUsingHeaderInterceptor) {

            headerInterceptor = new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request newRequest = chain.request().newBuilder()
                            .addHeader(Constants.HTTP_HEADER_ACCEPT, Constants.HTTP_HEADER_ACCEPT_VALUE)
                            .addHeader(Constants.HTTP_HEADER_SECURITY_TOKEN, mDeviceUuid)
                            .addHeader(Constants.HTTP_HEADER_SECURITY_SECRET, mSecret)
                            .addHeader(Constants.HTTP_HEADER_SECURITY_CREATED, String.valueOf(mCreated))
                            .addHeader(Constants.HTTP_HEADER_SECURITY_RAND, String.valueOf(mRand))
                            .build();
                    return chain.proceed(newRequest);
                }
            };
        }

        TrustManager [] trustAllCerts       = new TrustManager [] { trustManager () };

        SSLContext sslContext = SSLContext.getInstance (SSL);
        sslContext.init (null, trustAllCerts, new SecureRandom ());

        SSLSocketFactory sslSocketFactory   = sslContext.getSocketFactory ();

        OkHttpClient.Builder builder        = new OkHttpClient.Builder ();

        if(usingCache) {
            Log.d("GetHttpClient", "usingCache = true");
            builder.cache(new Cache(mCacheDir, CACHE_SIZE));
        }

        builder.addInterceptor(logging);
        if(headerInterceptor != null) {
            builder.addInterceptor(headerInterceptor);
        }

        builder.sslSocketFactory (sslSocketFactory, (X509TrustManager)trustAllCerts [0]);
        builder.hostnameVerifier (hostnameVerifier ());

        return builder.build ();
    }

    private static TrustManager trustManager () {
        return new X509TrustManager () {

            @Override
            public void checkClientTrusted (X509Certificate [] chain, String authType) throws CertificateException {  }

            @Override
            public void checkServerTrusted (X509Certificate[] chain, String authType) throws CertificateException {  }

            @Override
            public X509Certificate [] getAcceptedIssuers () {
                return new X509Certificate [] {  };
            }
        };
    }

    private static HostnameVerifier hostnameVerifier () {
        return new HostnameVerifier () {

            @Override
            public boolean verify (String hostname, SSLSession session) {
                return true;
            }
        };
    }
}