BodyTech v7.6.4 - a.java 源代码

package g6;

import com.android.volley.AuthFailureError;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;
import com.newrelic.agent.android.NewRelic;
import com.newrelic.agent.android.util.NetworkFailure;
import ff.c;
import h1.b;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import org.koin.core.Application;
import org.koin.core.exception.ApplicationException;
import org.koin.core.model.BaseMindBodyResponse;
import org.koin.core.server.api.xml.parsers.BaseMindBodyResponseParser;
import p6.j0;
import qf.f;

public abstract class a<P, R extends BaseMindBodyResponse> extends c<R> {

    protected b f2879p;

    private final Response.Listener<R> f2880q;

    private boolean f2881r;

    private final P f2882t;

    private long f2883v;

    private long f2884w;

    public a(String str, P p8, Response.ErrorListener errorListener, Response.Listener<R> listener) {
        super(1, of.a.p().soap + str, errorListener);
        this.f2880q = listener;
        this.f2881r = false;
        this.f2879p = h1.a.k(Application.d()).f();
        this.f2882t = p8;
        setRetryPolicy(new DefaultRetryPolicy(30000, 0, 1.0f));
        setShouldCache(false);
    }

    private void m(BaseMindBodyResponse baseMindBodyResponse) throws ApplicationException {
        boolean z7;
        String errorCode;
        String message;
        if (baseMindBodyResponse == null) {
            message = "Unexpected server response";
            errorCode = "MindBody.UnexpectedServerResponse";
            z7 = true;
        } else if (!baseMindBodyResponse.isSuccess() || "9999".equals(baseMindBodyResponse.getErrorCode())) {
            z7 = this.f2881r;
            errorCode = baseMindBodyResponse.getErrorCode();
            message = baseMindBodyResponse.getMessage();
            if (!"106".equals(errorCode)) {
                if ("101".equals(errorCode)) {
                    NewRelic.noticeNetworkFailure(getUrl(), "POST", this.f2883v, this.f2884w, NetworkFailure.fromErrorCode(401), "ErrorCode: {" + errorCode + "} Message: {" + message + "}");
                } else {
                    NewRelic.noticeNetworkFailure(getUrl(), "POST", this.f2883v, this.f2884w, NetworkFailure.BadServerResponse, "ErrorCode: {" + errorCode + "} Message: {" + message + "}");
                }
            }
        } else {
            errorCode = null;
            message = null;
            z7 = false;
        }
        if (z7) {
            throw new ApplicationException(String.format("Error in response for action = %1$s", j()), errorCode, message);
        }
    }

    public void deliverError(VolleyError volleyError) {
        if (isCanceled()) {
            return;
        }
        NetworkResponse networkResponse = volleyError.networkResponse;
        super.deliverError(volleyError);
    }

    protected abstract String g(b bVar, P p8);

    public final byte[] getBody() throws AuthFailureError {
        String g = g(this.f2879p, this.f2882t);
        return g != null ? g.getBytes(StandardCharsets.UTF_8) : super/*com.android.volley.Request*/.getBody();
    }

    public String getBodyContentType() {
        return "text/xml; charset=utf-8";
    }

    public String getCacheKey() {
        String str;
        try {
            str = new String(getBody(), StandardCharsets.UTF_8);
        } catch (AuthFailureError e) {
            mo.a.g(e, "Error while parsing the request body", new Object[0]);
            str = "";
        }
        return j() + "/" + str.hashCode();
    }

    public Map<String, String> getHeaders() throws AuthFailureError {
        HashMap j7 = of.a.j();
        j7.put("SOAPAction", j());
        of.a.b(j7);
        return j7;
    }

    public void deliverResponse(R r8) {
        if (this.f2880q == null || isCanceled()) {
            return;
        }
        this.f2880q.onResponse(r8);
    }

    public void i() {
        this.f2883v = System.currentTimeMillis();
        f.n().z(this, Application.d());
    }

    protected abstract String j();

    protected abstract BaseMindBodyResponseParser<R> k();

    protected void l(boolean z7) {
        this.f2881r = z7;
    }

    protected Response<R> parseNetworkResponse(NetworkResponse networkResponse) {
        this.f2884w = System.currentTimeMillis();
        ((c) this).d = true;
        try {
            StringReader stringReader = new StringReader(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers)));
            BaseMindBodyResponseParser<R> k8 = k();
            BaseMindBodyResponse baseMindBodyResponse = (BaseMindBodyResponse) j0.a(stringReader, k8.n(), k8);
            m(baseMindBodyResponse);
            return Response.success(baseMindBodyResponse, HttpHeaderParser.parseCacheHeaders(networkResponse));
        } catch (ApplicationException e) {
            return "101".equals(e.a()) ? Response.error(new AuthFailureError(new NetworkResponse(401, networkResponse.data, networkResponse.notModified, networkResponse.networkTimeMs, networkResponse.allHeaders))) : Response.error(new ParseError(new NetworkResponse(Integer.parseInt(e.a()), networkResponse.data, networkResponse.notModified, networkResponse.networkTimeMs, networkResponse.allHeaders)));
        } catch (Exception e8) {
            return Response.error(new ParseError(e8));
        }
    }
}