BodyTech v7.6.4 - c.java 源代码

package hf;

import android.annotation.SuppressLint;
import android.app.Application;
import android.content.SharedPreferences;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.mindbodyonline.android.auth.okhttp.domain.model.OAuthBasicToken;
import com.mindbodyonline.android.util.TaskCallback;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

public class c implements hf.d {
    private static Map<hf.a, c> i = new HashMap();
    private RequestQueue a;
    private hf.b b;
    private hf.a c;
    private final SharedPreferences d;
    private hf.d g;
    private AtomicBoolean e = new AtomicBoolean(false);
    private final List<Request> f = Collections.synchronizedList(new ArrayList());
    private List<TaskCallback> h = new ArrayList();

    class a implements Response.Listener<hf.b> {
        final Response.Listener c;

        a(Response.Listener listener) {
            this.c = listener;
        }

        public void onResponse(hf.b bVar) {
            this.c.onResponse(bVar);
        }
    }

    class b implements Response.Listener<hf.b> {
        final Response.Listener c;

        b(Response.Listener listener) {
            this.c = listener;
        }

        public void onResponse(hf.b bVar) {
            c.this.n(bVar);
            c.this.e.set(false);
            this.c.onResponse(bVar);
        }
    }

    class C0094c implements Response.ErrorListener {
        final Response.Listener c;
        final Response.ErrorListener d;

        C0094c(Response.Listener listener, Response.ErrorListener errorListener) {
            this.c = listener;
            this.d = errorListener;
        }

        public void onErrorResponse(VolleyError volleyError) {
            c.this.e.set(false);
            if (c.this.b == null || c.this.b.needsRefresh()) {
                this.d.onErrorResponse(volleyError);
            } else {
                this.c.onResponse(c.this.b);
            }
        }
    }

    class d implements TaskCallback<hf.b> {
        d() {
        }

        @Override
        public void b() {
            cf.e.a(this);
        }

        @Override
        public void a(hf.b bVar) {
            c.this.i(bVar);
        }
    }

    class e implements Response.Listener<hf.b> {
        final Request c;

        e(Request request) {
            this.c = request;
        }

        public void onResponse(hf.b bVar) {
            c.this.n(bVar);
            c.this.h(bVar, this.c);
            c.this.i(bVar);
        }
    }

    private c(hf.a aVar, RequestQueue requestQueue, Application application) {
        this.a = requestQueue;
        this.c = aVar;
        this.d = application.getSharedPreferences(aVar.f(), 0);
    }

    private void g(Map<String, String> map, Request request) {
        try {
            request.getHeaders().putAll(map);
            this.a.add(request);
        } catch (Exception e2) {
            request.deliverError(new VolleyError("Attaching header failed.", e2));
        }
    }

    public void h(hf.b bVar, Request request) {
        g(j(bVar), request);
    }

    private static Map<String, String> j(hf.b bVar) {
        HashMap hashMap = new HashMap();
        hashMap.put(OAuthBasicToken.OAUTH_HEADER_KEY, "Bearer " + bVar.getAccessToken());
        return hashMap;
    }

    public static c k(hf.a aVar, RequestQueue requestQueue, Application application) {
        if (!i.containsKey(aVar)) {
            i.put(aVar, new c(aVar, requestQueue, application));
        }
        return i.get(aVar);
    }

    private ff.c m(Response.Listener<hf.b> listener, Response.ErrorListener errorListener) {
        hf.b bVar = this.b;
        if (bVar == null || bVar.getRefreshToken() == null) {
            errorListener.onErrorResponse(new VolleyError("Token is null.  Make sure to call setToken() before running API calls."));
            return null;
        }
        this.e.set(true);
        ff.b bVar2 = new ff.b(1, this.c.b(), hf.b.class, this.c.c(), this.c.d(this.b), new b(listener), new C0094c(listener, errorListener));
        this.a.add(bVar2);
        return bVar2;
    }

    private void p(Request request) {
        e eVar = new e(request);
        if (l() == null) {
            g(this.c.g(), request);
            return;
        }
        hf.d dVar = this.g;
        if (dVar != null) {
            dVar.c(eVar, request.getErrorListener());
        } else {
            c(eVar, request.getErrorListener());
        }
    }

    @Override
    public void a(TaskCallback taskCallback) {
        if (this.h.contains(taskCallback)) {
            return;
        }
        this.h.add(taskCallback);
    }

    @Override
    public boolean b() {
        hf.d dVar = this.g;
        return dVar != null ? dVar.b() : this.e.get();
    }

    @Override
    public void c(Response.Listener<hf.b> listener, Response.ErrorListener errorListener) {
        if (l() == null) {
            errorListener.onErrorResponse(new VolleyError("Token is null.  Make sure to call setToken() before running API calls."));
        } else if (this.b.needsRefresh()) {
            m(new a(listener), errorListener);
        } else {
            listener.onResponse(this.b);
        }
    }

    public void i(hf.b bVar) {
        if (b()) {
            return;
        }
        synchronized (this.f) {
            try {
                Iterator<Request> it = this.f.iterator();
                while (it.hasNext()) {
                    Request next = it.next();
                    it.remove();
                    if (bVar == null) {
                        g(this.c.g(), next);
                    } else {
                        h(bVar, next);
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        Iterator<TaskCallback> it2 = this.h.iterator();
        while (it2.hasNext()) {
            it2.next().b();
        }
    }

    public hf.b l() {
        if (this.b == null) {
            this.b = (hf.b) cf.d.b(this.d.getString("oauth_token", ""), hf.b.class);
        }
        return this.b;
    }

    @SuppressLint({"ApplySharedPref"})
    public void n(hf.b bVar) {
        SharedPreferences.Editor edit = this.d.edit();
        this.b = bVar;
        if (bVar == null) {
            edit.remove("oauth_token");
        } else {
            if (bVar.getExpiration() == null) {
                bVar.timeStamp();
            }
            edit.putString("oauth_token", cf.d.g(this.b));
        }
        edit.commit();
    }

    public void o(hf.d dVar) {
        this.g = dVar;
        if (dVar != null) {
            dVar.a(new d());
        }
    }

    public void q(Request request) {
        if (!b()) {
            p(request);
            return;
        }
        synchronized (this.f) {
            this.f.add(request);
        }
    }
}