HttpGet

package com.example.view.utils;

import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;

import com.google.gson.Gson;

import java.io.IOException;
import java.util.HashMap;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Request;
import okhttp3.Response;

public class HttpGet<T> {
    private final static String TAG = "HttpGet";
    private T mData;
    private Class<T> mClassOfT;
    private Handler mMainHandler = new Handler(Looper.getMainLooper());
    private Call mCall;
    private boolean mCancelFlag = false;
    private boolean mGetFlag = false;

    public interface IGetCallback<T>{
        void onFail(Exception exception);
        void onSuccess(T data);
    }

    private IGetCallback mListener;

    public HttpGet(Class<T> classOfT){
        mClassOfT = classOfT;
    }

    public synchronized void setGetCallback(IGetCallback listener){
        mListener = listener;
    }

    public synchronized IGetCallback getGetCallback(){
        return mListener;
    }

    public synchronized void cancel(){
        if(mCancelFlag){
            return;
        }
        mListener = null;
        mCancelFlag = true;
        cancelCall();
    }

    public synchronized boolean isCancel(){
        return mCancelFlag;
    }

    public void get(String url, HashMap<String, String> paraMap){
        StringBuilder sb = new StringBuilder();
        boolean firstFlag = true;
        if(paraMap != null) {
            for (String key : paraMap.keySet()) {
                String value = paraMap.get(key);
                if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(value)) {
                    if (!firstFlag) {
                        sb.append("&");
                    }
                    sb.append(key).append("=").append(value);
                    firstFlag = false;
                }
            }
        }
        if(sb.length() > 0) {
            get(url + "?" + sb.toString());
        } else{
            get(url);
        }
    }

    public void get(String url){
        if(isCancel()){
            return;
        }
        synchronized (this){
            if(mGetFlag){
                throw new IllegalStateException(" the task has already been executed "
                        + "(a task can be executed only once)");
            }
            mGetFlag = true;
        }

        Log.i(TAG, "onResponse, url = " + url);
        Request request = new Request.Builder().get().url(url).build();
        Call call = OkHttpUtil.getHttpClient().newCall(request);
        setCall(call);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG, "onFailure, IOException = " + e);
                requestFail(e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String resultStr = null;
                Log.i(TAG, "onResponse, response = " + response);
                if(response != null && response.isSuccessful()){
                    try {
                        if(response.body() != null) {
                            resultStr = response.body().string();
                        }
                    }catch (IOException e){
                        e.printStackTrace();
                        Log.i(TAG, "onResponse, IOException = " + e);
                        requestFail(e);
                        return;
                    }
                }
                Log.i(TAG, "onResponse, resultStr = " + resultStr);
                if( TextUtils.isEmpty(resultStr) ){
                    requestFail(null);
                    return;
                }
                T data = null;
                Gson gson = new Gson();
                try {
                    data = gson.fromJson(resultStr, mClassOfT);
                } catch (Exception e){
                    e.printStackTrace();
                    requestFail(e);
                    return;
                }

                if(data != null){
                    requestSucess(data);
                } else{
                    requestFail(null);
                }
            }
        });
    }

    private synchronized void cancelCall(){
        if(mCall != null){
            mCall.cancel();
        }
        mCall = null;
    }

    private synchronized boolean isGet(){
        return mGetFlag;
    }

    private synchronized void setCall(Call call){
         mCall = call;
    }

    private void requestFail(Exception e){
        if(isCancel()){
            return;
        }

        mMainHandler.post(new Runnable() {
            @Override
            public void run() {
                if(isCancel()){
                    return;
                }
                IGetCallback<T> listener = getGetCallback();
                if(listener != null){
                    listener.onFail(e);
                }
            }
        });
    }

    private void requestSucess(T data){
        if(isCancel()){
            return;
        }
        mMainHandler.post(new Runnable() {
            @Override
            public void run() {
                if(isCancel()){
                    return;
                }
                IGetCallback<T> listener = getGetCallback();
                if(listener != null){
                    listener.onSuccess(data);
                }
            }
        });
    }
}