package com.ifpdos.Utils.okhttp;

import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.ifpdos.factorytest.entity.EmptyBody;
import com.ifpdos.udi.sdk.UdiSdk;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

/* JADX INFO: loaded from: classes.dex */
public class OkHttpHelper {
    public static final String TAG = "OkHttpHelper";
    public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    private static OkHttpHelper mInstance = new OkHttpHelper();
    private OkHttpClient mHttpClient = UdiSdk.newOkHttpClientBuilder().callTimeout(5, TimeUnit.SECONDS).build();
    private Gson mGson = new Gson();
    private Handler mHandler = new Handler(Looper.getMainLooper());

    enum HttpMethodType {
        GET,
        POST
    }

    private OkHttpHelper() {
    }

    public static OkHttpHelper getInstance() {
        return mInstance;
    }

    public void get(String str, BaseCallback baseCallback) {
        request(buildGetRequest(str), baseCallback);
    }

    public <T> T get(String str, Class<T> cls) {
        return (T) request(buildGetRequest(str), cls);
    }

    public void post(String str, Map<String, String> map, BaseCallback baseCallback) {
        request(buildPostRequest(str, map), baseCallback);
    }

    public Response post(String str, Map<String, String> map) {
        try {
            return executeSync(buildPostRequest(str, map));
        } catch (Exception e) {
            Log.e(TAG, "post: error", e);
            return null;
        }
    }

    public <T> T postSync(String str, String str2, Class<T> cls) {
        return (T) request(buildPostRequest(str, str2), cls);
    }

    public <T> T postSync(String str, Map<String, String> map, Class<T> cls) {
        return (T) request(buildPostRequest(str, map), cls);
    }

    public void request(final Request request, final BaseCallback baseCallback) {
        baseCallback.onBeforeRequest(request);
        this.mHttpClient.newCall(request).enqueue(new Callback() { // from class: com.ifpdos.Utils.okhttp.OkHttpHelper.1
            @Override // okhttp3.Callback
            public void onResponse(Call call, Response response) throws IOException {
                baseCallback.onResponse(response);
                if (response.isSuccessful()) {
                    String strString = response.body().string();
                    Log.d(OkHttpHelper.TAG, "result=" + strString);
                    if (baseCallback.mType == String.class || TextUtils.isEmpty(strString)) {
                        OkHttpHelper.this.callbackSuccess(baseCallback, response, strString);
                        return;
                    }
                    try {
                        OkHttpHelper.this.callbackSuccess(baseCallback, response, OkHttpHelper.this.mGson.fromJson(strString, baseCallback.mType));
                        return;
                    } catch (JsonParseException e) {
                        baseCallback.onError(response, response.code(), e);
                        return;
                    }
                }
                OkHttpHelper.this.callbackError(baseCallback, response, null);
            }

            @Override // okhttp3.Callback
            public void onFailure(Call call, IOException iOException) {
                baseCallback.onFailure(request, iOException);
            }
        });
    }

    public synchronized <T> T request(Request request, Class<T> cls) {
        try {
            Response responseExecuteSync = executeSync(request);
            Log.d(TAG, "code: " + responseExecuteSync.code());
            String strString = responseExecuteSync.body().string();
            Log.d(TAG, "body: " + strString);
            if (responseExecuteSync.code() != 200) {
                return null;
            }
            T t = (T) new Gson().fromJson(strString, (Class) cls);
            Log.i(TAG, "code：200，body result:" + t);
            if (t != null) {
                return t;
            }
            return (T) new EmptyBody();
        } catch (IOException unused) {
            return null;
        }
    }

    public Response executeSync(String str) throws IOException {
        return this.mHttpClient.newCall(new Request.Builder().url(UdiSdk.getFullUrl(str)).build()).execute();
    }

    public Response executeSync(Request request) throws IOException {
        return this.mHttpClient.newCall(request).execute();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void callbackSuccess(final BaseCallback baseCallback, final Response response, final Object obj) {
        this.mHandler.post(new Runnable() { // from class: com.ifpdos.Utils.okhttp.OkHttpHelper$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                baseCallback.onSuccess(response, obj);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void callbackError(final BaseCallback baseCallback, final Response response, final Exception exc) {
        this.mHandler.post(new Runnable() { // from class: com.ifpdos.Utils.okhttp.OkHttpHelper$$ExternalSyntheticLambda1
            @Override // java.lang.Runnable
            public final void run() {
                BaseCallback baseCallback2 = baseCallback;
                Response response2 = response;
                baseCallback2.onError(response2, response2.code(), exc);
            }
        });
    }

    private Request buildPostRequest(String str, Map<String, String> map) {
        return buildRequest(str, HttpMethodType.POST, map);
    }

    private Request buildPostRequest(String str, String str2) {
        return buildRequest(str, HttpMethodType.POST, str2);
    }

    private Request buildGetRequest(String str) {
        return buildRequest(str, HttpMethodType.GET, "");
    }

    private Request buildRequest(String str, HttpMethodType httpMethodType, Map<String, String> map) {
        Request.Builder builderUrl = new Request.Builder().url(UdiSdk.getFullUrl(str));
        if (httpMethodType == HttpMethodType.POST) {
            builderUrl.post(builderFormData(map));
        } else if (httpMethodType == HttpMethodType.GET) {
            builderUrl.get();
        }
        return builderUrl.build();
    }

    private Request buildRequest(String str, HttpMethodType httpMethodType, String str2) {
        Request.Builder builderUrl = new Request.Builder().url(UdiSdk.getFullUrl(str));
        if (httpMethodType == HttpMethodType.POST) {
            builderUrl.post(RequestBody.create(JSON, str2));
        } else if (httpMethodType == HttpMethodType.GET) {
            builderUrl.get();
        }
        return builderUrl.build();
    }

    private RequestBody builderFormData(Map<String, String> map) {
        JsonObject jsonObject = new JsonObject();
        if (map != null) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                jsonObject.addProperty(entry.getKey(), entry.getValue());
            }
        }
        return RequestBody.create(JSON, new Gson().toJson((JsonElement) jsonObject));
    }
}