BodyTech v7.6.4 - b.java 源代码

package ff;

import android.text.TextUtils;
import cf.d;
import com.android.volley.AuthFailureError;
import com.android.volley.Cache;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Response;
import com.android.volley.toolbox.HttpHeaderParser;
import com.mindbodyonline.android.util.api.error.EmptyResponseError;
import com.newrelic.agent.android.util.Constants;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.util.Map;

public class b<T> extends c<T> implements Response.ErrorListener {
    private Class<T> p;
    private Type q;
    private final String r;
    private boolean t;

    public b(int i, String str, Class<T> cls, Map<String, String> map, Response.Listener<T> listener, Response.ErrorListener errorListener) {
        this(i, str, cls, map, (String) null, listener, errorListener);
    }

    private boolean g(NetworkResponse networkResponse) {
        Map map = networkResponse.headers;
        return (map == null || !map.containsKey(Constants.Network.CONTENT_TYPE_HEADER) || ((String) networkResponse.headers.get(Constants.Network.CONTENT_TYPE_HEADER)).contains(Constants.Network.ContentType.JSON)) ? false : true;
    }

    private boolean i() {
        Class<T> cls;
        return !this.t && ((cls = this.p) == null || !Void.class.isAssignableFrom(cls));
    }

    public byte[] getBody() throws AuthFailureError {
        String str = this.r;
        if (str != null) {
            try {
                return str.getBytes("UTF-8");
            } catch (UnsupportedEncodingException e) {
                jf.a.c(b.class.getName(), "getBody", e);
            }
        }
        return super.getBody();
    }

    public String getBodyContentType() {
        try {
            return getHeaders().containsKey(Constants.Network.CONTENT_TYPE_HEADER) ? getHeaders().get(Constants.Network.CONTENT_TYPE_HEADER) : Constants.Network.ContentType.JSON;
        } catch (AuthFailureError unused) {
            return Constants.Network.ContentType.JSON;
        }
    }

    public void h(boolean z) {
        this.t = z;
    }

    protected Response<T> parseNetworkResponse(NetworkResponse networkResponse) {
        this.d = true;
        if (networkResponse != null && networkResponse.statusCode == 204) {
            jf.a.a("MBDataService", "RESPONSE::STATUS=" + networkResponse.statusCode + "::FROM=" + getUrl());
            return Response.success((Object) null, (Cache.Entry) null);
        }
        try {
            String str = new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "UTF-8"));
            Class<T> cls = this.p;
            Object b = cls != null ? d.b(str, cls) : d.c(str, this.q);
            if ((b != null && !"{}".equals(str)) || (!g(networkResponse) && !i())) {
                if (!TextUtils.isEmpty(str)) {
                    str = str.replace("\n", "").replace("\r", "");
                }
                jf.a.a("MBDataService", "RESPONSE::STATUS=" + networkResponse.statusCode + "::FROM=" + getUrl() + " ::CONTENT=" + str);
                return Response.success(b, HttpHeaderParser.parseCacheHeaders(networkResponse));
            }
            jf.a.b("MBDataService", "ERR_RESPONSE::" + networkResponse.statusCode + "::FROM=" + getUrl() + " :: Invalid null parsing of object from server");
            return Response.error(parseNetworkError(new EmptyResponseError(networkResponse)));
        } catch (UnsupportedEncodingException e) {
            byte[] bArr = networkResponse.data;
            if (bArr == null || bArr.length <= 0) {
                jf.a.a("MBDataService", "RESPONSE::STATUS=" + networkResponse.statusCode + "::FROM=" + getUrl() + " ::CONTENT=null::ERROR=" + e.getMessage());
            } else {
                jf.a.a("MBDataService", "RESPONSE::STATUS=" + networkResponse.statusCode + "::FROM=" + getUrl() + " ::CONTENT=" + new String(networkResponse.data) + "::ERROR=" + e.getMessage());
            }
            return Response.error(new ParseError(e));
        }
    }

    public b(int i, String str, Class<T> cls, Map<String, String> map, String str2, Response.Listener<T> listener, Response.ErrorListener errorListener) {
        this(i, str, map, (Type) null, str2, listener, errorListener);
        this.p = cls;
    }

    public b(int i, String str, Map<String, String> map, Type type, String str2, Response.Listener<T> listener, Response.ErrorListener errorListener) {
        super(i, str, null);
        if (i == 1 && str2 == null) {
            str2 = "";
        }
        this.q = type;
        this.r = str2;
        c(map);
        e(listener);
        d(errorListener);
        setRetryPolicy(new DefaultRetryPolicy(30000, 0, 1.0f));
    }
}