package com.ifpdos.udi.sdk.binderhttpd;

import android.annotation.SuppressLint;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.ifpdos.sdk.httpd.binder.aidl.IEventListener;
import com.ifpdos.sdk.httpd.binder.aidl.IServer;
import com.ifpdos.sdk.httpd.binder.aidl.Request;
import com.ifpdos.sdk.httpd.binder.aidl.Response;
import com.ifpdos.udi.sdk.AddEventResponse;
import com.ifpdos.udi.sdk.IConnectCallback;
import com.ifpdos.udi.sdk.IEventHandler;
import com.ifpdos.udi.sdk.IEventHelper;
import com.ifpdos.udi.sdk.UdiSdk;
import com.ifpdos.udi.sdk.UdiStartMonitor;
import d.b.a.a.a;
import d.f.d.a.a.b;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;

/* JADX INFO: loaded from: classes.dex */
public class BinderEventHelper implements IEventHelper, UdiStartMonitor.IUdiStartListener {
    private static final int DEFAULT_RETRY_LIMIT = 180;
    private static final int RETRY_DELAY = 1000;
    private static final String TAG = "BinderEventHelper";
    private static final String URI_EVENTS_ADD = "/v1/udi/events/add";
    private static final String URI_EVENTS_REMOVE = "/v1/udi/events/remove";
    private final IConnectCallback mCallback;
    private final b mDns;
    private String mToken;
    private final RetryHandler mHandler = new RetryHandler();
    private IServer mServer = null;
    private final Map<String, Set<IEventHandler>> mHandlerMap = new ConcurrentHashMap();
    private final Map<IEventHandler, Set<String>> mEventMap = new ConcurrentHashMap();
    private final IEventListener mEventListener = new IEventListener.Stub() { // from class: com.ifpdos.udi.sdk.binderhttpd.BinderEventHelper.1
        @Override // com.ifpdos.sdk.httpd.binder.aidl.IEventListener
        public void onEvent(String str, String str2) throws RemoteException {
            BinderEventHelper.this.dispatchEvent(str, str2);
        }
    };
    private final Map<String, Integer> mEventToRetry = new ConcurrentHashMap();
    private final Gson mGson = new Gson();
    private int mRetryLimit = 180;

    public static class AddRequestBody {

        @SerializedName("events")
        public Set<String> events;

        public AddRequestBody(Set<String> set) {
            this.events = set;
        }
    }

    @SuppressLint({"HandlerLeak"})
    public class RetryHandler extends Handler {
        public static final int MSG_RETRY_ADD_EVENT = 2;
        public static final int MSG_RETRY_CONNECT = 1;
        private int mConnectRetryTime;

        public RetryHandler() {
            super(Looper.getMainLooper());
            this.mConnectRetryTime = 0;
        }

        /* JADX INFO: Access modifiers changed from: private */
        public void resetConnectRetryTime() {
            this.mConnectRetryTime = 0;
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            super.handleMessage(message);
            int i2 = message.what;
            if (i2 == 1) {
                BinderEventHelper.this.connectServer();
            } else if (i2 == 2) {
                BinderEventHelper.this.registerEvents(new HashSet(BinderEventHelper.this.mEventToRetry.keySet()));
            }
        }

        public void retryAddEvent() {
            removeMessages(2);
            sendEmptyMessageDelayed(2, 1000L);
        }

        public boolean retryConnect() {
            if (this.mConnectRetryTime >= BinderEventHelper.this.mRetryLimit) {
                return false;
            }
            this.mConnectRetryTime++;
            removeMessages(1);
            sendEmptyMessageDelayed(1, 1000L);
            return true;
        }
    }

    public BinderEventHelper(b bVar, IConnectCallback iConnectCallback) {
        this.mDns = bVar;
        this.mCallback = iConnectCallback;
        connectServer();
        UdiStartMonitor.registerListener(this);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void connectServer() {
        if (getServer() != null) {
            this.mCallback.onSuccess();
            registerEvents(this.mHandlerMap.keySet());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void dispatchEvent(String str, String str2) {
        Set<IEventHandler> set = this.mHandlerMap.get(str);
        if (set == null) {
            return;
        }
        Iterator<IEventHandler> it = set.iterator();
        while (it.hasNext()) {
            it.next().onEvent(str, str2);
        }
    }

    private synchronized Set<String> getEventsForHandler(IEventHandler iEventHandler) {
        Set<String> hashSet;
        hashSet = this.mEventMap.get(iEventHandler);
        if (hashSet == null) {
            hashSet = new HashSet<>();
            this.mEventMap.put(iEventHandler, hashSet);
        }
        return hashSet;
    }

    private synchronized Set<IEventHandler> getHandlersForEvent(String str) {
        Set<IEventHandler> copyOnWriteArraySet;
        copyOnWriteArraySet = this.mHandlerMap.get(str);
        if (copyOnWriteArraySet == null) {
            copyOnWriteArraySet = new CopyOnWriteArraySet<>();
            this.mHandlerMap.put(str, copyOnWriteArraySet);
            registerEvents(new HashSet<String>(str) { // from class: com.ifpdos.udi.sdk.binderhttpd.BinderEventHelper.2
                public final /* synthetic */ String val$event;

                {
                    this.val$event = str;
                    add(str);
                }
            });
        }
        return copyOnWriteArraySet;
    }

    private IServer getServer() {
        IServer iServer = this.mServer;
        if (iServer != null && pingServer(iServer)) {
            return this.mServer;
        }
        IServer iServerC = this.mDns.c(UdiSdk.HOST);
        this.mServer = iServerC;
        if (iServerC == null) {
            this.mHandler.retryConnect();
        }
        return this.mServer;
    }

    private AddEventResponse parserAddEventResponse(String str) {
        try {
            return (AddEventResponse) this.mGson.fromJson(str, AddEventResponse.class);
        } catch (Exception e2) {
            Log.d("UdiSdk", "parserAddEventResponse failed", e2);
            return null;
        }
    }

    private boolean pingServer(IServer iServer) {
        try {
            return iServer.asBinder().pingBinder();
        } catch (Exception unused) {
            return false;
        }
    }

    private void retryAddEvent(Set<String> set) {
        for (String str : set) {
            if (!this.mEventToRetry.containsKey(str)) {
                this.mEventToRetry.put(str, 0);
            }
        }
        Iterator<Map.Entry<String, Integer>> it = this.mEventToRetry.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> next = it.next();
            if (next.getValue().intValue() > this.mRetryLimit) {
                Log.d("UdiSdk", next.getKey() + " add failed, retry " + this.mRetryLimit + " times");
                it.remove();
            } else {
                next.setValue(Integer.valueOf(next.getValue().intValue() + 1));
            }
        }
        this.mHandler.retryAddEvent();
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public void destroy() {
        unregisterEvents(this.mHandlerMap.keySet());
        UdiStartMonitor.unregisterListener(this);
        this.mEventMap.clear();
        this.mHandlerMap.clear();
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public Map<IEventHandler, Set<String>> getHandlerMap() {
        return this.mEventMap;
    }

    @Override // com.ifpdos.udi.sdk.UdiStartMonitor.IUdiStartListener
    public void onUdiStart() {
        Log.d("UdiSdk", "onUdiStart");
        this.mHandler.resetConnectRetryTime();
        this.mHandler.retryConnect();
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void registerEvents(Set<String> set, IEventHandler iEventHandler) {
        for (String str : set) {
            this.mEventToRetry.put(str, 0);
            getHandlersForEvent(str).add(iEventHandler);
        }
        getEventsForHandler(iEventHandler).addAll(set);
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public void setToken(String str) {
        this.mToken = str;
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(Set<String> set, IEventHandler iEventHandler) {
        HashSet hashSet = new HashSet();
        for (String str : set) {
            if (this.mHandlerMap.containsKey(str)) {
                Set<IEventHandler> handlersForEvent = getHandlersForEvent(str);
                handlersForEvent.remove(iEventHandler);
                if (handlersForEvent.isEmpty()) {
                    hashSet.add(str);
                    this.mHandlerMap.remove(str);
                }
            }
        }
        Set<String> eventsForHandler = getEventsForHandler(iEventHandler);
        eventsForHandler.removeAll(set);
        if (eventsForHandler.isEmpty()) {
            this.mEventMap.remove(iEventHandler);
        }
        unregisterEvents(hashSet);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void registerEvents(Set<String> set) {
        List<String> list;
        List<String> list2;
        IServer server = getServer();
        if (server == null) {
            return;
        }
        AddRequestBody addRequestBody = new AddRequestBody(set);
        String json = this.mGson.toJson(addRequestBody);
        if (UdiSdk.isDebug()) {
            StringBuilder sbB = a.B("register ");
            sbB.append(addRequestBody.events.size());
            sbB.append(" events: ");
            sbB.append(json);
            Log.d("UdiSdk", sbB.toString());
        }
        try {
            Response responseAddEventListener = server.addEventListener(new Request.Builder().addHeader("token", this.mToken).post(URI_EVENTS_ADD, json).build(), this.mEventListener);
            if (responseAddEventListener.getCode() == 503) {
                AddEventResponse addEventResponse = parserAddEventResponse(responseAddEventListener.getStringBody());
                if (addEventResponse != null && (list2 = addEventResponse.success) != null) {
                    Iterator<String> it = list2.iterator();
                    while (it.hasNext()) {
                        this.mEventToRetry.remove(it.next());
                    }
                }
                if (addEventResponse == null || (list = addEventResponse.retry) == null || list.isEmpty()) {
                    return;
                }
                retryAddEvent(new HashSet(addEventResponse.retry));
                return;
            }
            Log.d("UdiSdk", "addEventListener response " + responseAddEventListener.getCode());
        } catch (Exception e2) {
            Log.e("UdiSdk", "registerEvents failed", e2);
        }
    }

    private void unregisterEvents(Set<String> set) {
        IServer server = getServer();
        if (server == null) {
            return;
        }
        try {
            server.removeEventListener(new Request.Builder().addHeader("token", this.mToken).post(URI_EVENTS_REMOVE, this.mGson.toJson(new AddRequestBody(set))).build(), this.mEventListener);
        } catch (Exception e2) {
            Log.e("UdiSdk", "removeEventListener failed", e2);
        }
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(IEventHandler iEventHandler) {
        if (this.mEventMap.containsKey(iEventHandler)) {
            unregisterEvents(getEventsForHandler(iEventHandler), iEventHandler);
        }
    }
}