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;

            }

        };

    }

}