package com.ifpdos.udi.sdk;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.IBinder;
import android.util.Log;
import com.ifpdos.sdk.httpd.binder.BinderSocketDns;
import com.ifpdos.udi.sdk.UdiSdk;
import com.ifpdos.udi.sdk.binderhttpd.BinderEventHelper;
import com.ifpdos.udi.sdk.binderhttpd.BinderHttpdInterceptor;
import com.ifpdos.udi.sdk.binderhttpd.FixLastArrayList;
import com.ifpdos.udi.sdk.localhttpd.LocalSocketDns;
import com.ifpdos.udi.sdk.localhttpd.LocalSocketEventHelper;
import com.ifpdos.udi.sdk.localhttpd.LocalSocketFactory;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/* JADX INFO: loaded from: classes.dex */
public class UdiSdkEnvironment {
    private static final String PACKAGE_UDI_NO_OPENSDK = "com.ifpdos.udi.server";
    private static final String PACKAGE_UDI_OPENSDK = "com.seewo.mcuservice";
    public static final String TAG = "UdiSdk";
    private BinderSocketDns mBinderSocketDns;
    private IEventHelper mEventHelper;
    private UdiSdk.IOkHttpClientBuilderInterceptor mInterceptor;
    private boolean mIsSupportBinderHttpd;
    private String mPackage;
    private IConnectCallback mSseConnectCallback;
    private String mToken;
    private UdiStartMonitor mUdiStartMonitor;
    private Map<IEventHandler, Set<String>> mDelayToRegister = new HashMap();
    private boolean mSseConnectCreate = false;
    private boolean mSuccess = false;
    private IDependentFactory mDependentFactory = new DefaultDependentFactory();

    public interface IDependentFactory {
        BinderSocketDns buildBinderSocketDns(Context context);
    }

    UdiSdkEnvironment() {
    }

    public OkHttpClient.Builder newOkHttpClientBuilder() {
        if (this.mToken == null) {
            Log.e("UdiSdk", "a request was called before udi init, and this request call failed");
        }
        if (this.mIsSupportBinderHttpd) {
            return newBinderClientBuilder();
        }
        return newLocalSocketClientBuilder();
    }

    public OkHttpClient.Builder newLocalSocketClientBuilder() {
        OkHttpClient.Builder builderAddInterceptor = new OkHttpClient.Builder().socketFactory(new LocalSocketFactory()).dns(new LocalSocketDns()).addInterceptor(new TokenInterceptor());
        UdiSdk.IOkHttpClientBuilderInterceptor iOkHttpClientBuilderInterceptor = this.mInterceptor;
        return iOkHttpClientBuilderInterceptor != null ? iOkHttpClientBuilderInterceptor.adapt(builderAddInterceptor) : builderAddInterceptor;
    }

    private OkHttpClient.Builder newBinderClientBuilder() {
        OkHttpClient.Builder builderAddInterceptor = new OkHttpClient.Builder().addInterceptor(new TokenInterceptor()).addInterceptor(new BinderHttpdInterceptor(this.mBinderSocketDns));
        try {
            replaceBinderHttpdInterceptorList(builderAddInterceptor);
        } catch (Exception e) {
            Log.e("UdiSdk", "replaceBinderHttpdInterceptorList failed", e);
        }
        UdiSdk.IOkHttpClientBuilderInterceptor iOkHttpClientBuilderInterceptor = this.mInterceptor;
        return iOkHttpClientBuilderInterceptor != null ? iOkHttpClientBuilderInterceptor.adapt(builderAddInterceptor) : builderAddInterceptor;
    }

    private static void replaceBinderHttpdInterceptorList(OkHttpClient.Builder builder) throws IllegalAccessException {
        List list;
        Field[] declaredFields = builder.getClass().getDeclaredFields();
        for (int i = 0; i < declaredFields.length; i++) {
            declaredFields[i].setAccessible(true);
            if ((declaredFields[i].get(builder) instanceof List) && (list = (List) declaredFields[i].get(builder)) != null && !list.isEmpty() && (list.get(0) instanceof TokenInterceptor)) {
                FixLastArrayList fixLastArrayList = new FixLastArrayList();
                declaredFields[i].set(builder, fixLastArrayList);
                Iterator it = list.iterator();
                while (it.hasNext()) {
                    fixLastArrayList.addToLast((Interceptor) it.next());
                }
            }
        }
    }

    public void setOkHttpClientBuilderInterceptor(UdiSdk.IOkHttpClientBuilderInterceptor iOkHttpClientBuilderInterceptor) {
        this.mInterceptor = iOkHttpClientBuilderInterceptor;
    }

    public void setDependentFactory(IDependentFactory iDependentFactory) {
        this.mDependentFactory = iDependentFactory;
    }

    public void init(Context context, String str) {
        init(context, str, null);
    }

    private boolean isAppInstalled(Context context, String str) {
        PackageInfo packageInfo;
        if (str == null || str.isEmpty()) {
            return false;
        }
        try {
            packageInfo = context.getPackageManager().getPackageInfo(str, 0);
        } catch (PackageManager.NameNotFoundException unused) {
            packageInfo = null;
        }
        return packageInfo != null;
    }

    public void init(Context context, String str, final IConnectCallback iConnectCallback) {
        Log.d("UdiSdk", "start udi client sdk init");
        this.mToken = str;
        this.mPackage = context.getPackageName();
        this.mSseConnectCallback = iConnectCallback;
        boolean zIsAppInstalled = isAppInstalled(context, "com.seewo.mcuservice");
        boolean zIsAppInstalled2 = isAppInstalled(context, PACKAGE_UDI_NO_OPENSDK);
        if (!zIsAppInstalled && !zIsAppInstalled2) {
            Log.d("UdiSdk", "com.seewo.mcuservice and com.ifpdos.udi.server init failed");
            if (iConnectCallback != null) {
                iConnectCallback.onFailed();
                return;
            }
            return;
        }
        boolean zIsUdiSupportBinderHttpd = isUdiSupportBinderHttpd();
        this.mIsSupportBinderHttpd = zIsUdiSupportBinderHttpd;
        if (zIsUdiSupportBinderHttpd && this.mBinderSocketDns == null) {
            this.mBinderSocketDns = this.mDependentFactory.buildBinderSocketDns(context.getApplicationContext());
            BinderSocketDns.IServerAvailableListener iServerAvailableListener = iConnectCallback != null ? new BinderSocketDns.IServerAvailableListener() { // from class: com.ifpdos.udi.sdk.UdiSdkEnvironment.1
                @Override // com.ifpdos.sdk.httpd.binder.BinderSocketDns.IServerAvailableListener
                public void onServerAvailable(String str2, String str3) {
                    if (UdiSdkEnvironment.this.mSuccess) {
                        return;
                    }
                    UdiSdkEnvironment.this.mSuccess = true;
                    iConnectCallback.onSuccess();
                }
            } : null;
            if (zIsAppInstalled2) {
                this.mBinderSocketDns.addHostPackage(UdiSdk.HOST, PACKAGE_UDI_NO_OPENSDK, iServerAvailableListener);
            } else if (zIsAppInstalled) {
                this.mBinderSocketDns.addHostPackage(UdiSdk.HOST, "com.seewo.mcuservice", iServerAvailableListener);
            }
        } else {
            this.mSuccess = true;
            if (iConnectCallback != null) {
                iConnectCallback.onSuccess();
            }
        }
        if (this.mUdiStartMonitor == null) {
            this.mUdiStartMonitor = new UdiStartMonitor(context);
        }
    }

    private boolean isUdiSupportBinderHttpd() {
        return SystemPropertiesUtils.getBoolean(UdiSdk.PROP_UDI_BINDER_ENABLE, false) || SystemPropertiesUtils.getBoolean(UdiSdk.PROP_UDI_BINDER_ENABLE_SELINUX, false) || getSystemServer(UdiSdk.HOST) != null;
    }

    private IBinder getSystemServer(String str) {
        try {
            return (IBinder) Class.forName("android.os.ServiceManager").getMethod("getService", String.class).invoke(null, str);
        } catch (Exception e) {
            Log.d("UdiSdk", "getService failed", e);
            return null;
        }
    }

    public synchronized void destroy() {
        IEventHelper iEventHelper = this.mEventHelper;
        if (iEventHelper != null) {
            iEventHelper.destroy();
            this.mEventHelper = null;
            this.mSseConnectCreate = false;
        }
        this.mBinderSocketDns = null;
        this.mSuccess = false;
    }

    public synchronized void unregisterEvents(IEventHandler iEventHandler) {
        Log.d("UdiSdk", "unregisterEvents all event for " + iEventHandler);
        IEventHelper eventHelper = getEventHelper();
        if (this.mSseConnectCreate) {
            eventHelper.unregisterEvents(iEventHandler);
        } else {
            getEventsForHandler(iEventHandler).clear();
        }
    }

    public synchronized void unregisterEvents(List<String> list, IEventHandler iEventHandler) {
        unregisterEvents(new HashSet(list), iEventHandler);
    }

    public synchronized void unregisterEvents(Set<String> set, IEventHandler iEventHandler) {
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            Log.d("UdiSdk", "unregister  " + it.next() + " for " + iEventHandler);
        }
        IEventHelper eventHelper = getEventHelper();
        if (this.mSseConnectCreate) {
            eventHelper.unregisterEvents(set, iEventHandler);
        } else {
            getEventsForHandler(iEventHandler).removeAll(set);
        }
    }

    public synchronized void registerEvents(List<String> list, IEventHandler iEventHandler) {
        registerEvents(new HashSet(list), iEventHandler);
    }

    public synchronized void registerEvents(Set<String> set, IEventHandler iEventHandler) {
        if (iEventHandler == null) {
            Log.e("UdiSdk", "can not register null handler for events!", new Exception());
            return;
        }
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            Log.d("UdiSdk", "register  " + it.next() + " for " + iEventHandler);
        }
        IEventHelper eventHelper = getEventHelper();
        if (this.mSseConnectCreate) {
            eventHelper.registerEvents(set, iEventHandler);
        } else {
            getEventsForHandler(iEventHandler).addAll(set);
        }
    }

    private synchronized IEventHelper getEventHelper() {
        IEventHelper iEventHelper = this.mEventHelper;
        if (iEventHelper != null) {
            iEventHelper.setToken(this.mToken);
            return this.mEventHelper;
        }
        IConnectCallback iConnectCallback = new IConnectCallback() { // from class: com.ifpdos.udi.sdk.UdiSdkEnvironment.2
            @Override // com.ifpdos.udi.sdk.IConnectCallback
            public void onSuccess() {
                Log.d("UdiSdk", "sse connect onSuccess");
                UdiSdkEnvironment.this.onSseConnectCreate();
                if (UdiSdkEnvironment.this.mSuccess || UdiSdkEnvironment.this.mSseConnectCallback == null) {
                    return;
                }
                UdiSdkEnvironment.this.mSuccess = true;
                UdiSdkEnvironment.this.mSseConnectCallback.onSuccess();
            }

            @Override // com.ifpdos.udi.sdk.IConnectCallback
            public void onFailed() {
                Log.d("UdiSdk", "sse connect onFailed");
                if (UdiSdkEnvironment.this.mSseConnectCallback != null) {
                    UdiSdkEnvironment.this.mSseConnectCallback.onFailed();
                }
            }

            @Override // com.ifpdos.udi.sdk.IConnectCallback
            public void onDisconnect(Exception exc) {
                Log.e("UdiSdk", "sse connect onDisconnect", exc);
                Map<IEventHandler, Set<String>> handlerMap = UdiSdkEnvironment.this.mEventHelper.getHandlerMap();
                UdiSdkEnvironment.this.mEventHelper = null;
                UdiSdkEnvironment.this.mSseConnectCreate = false;
                if (UdiSdkEnvironment.this.mSseConnectCallback != null) {
                    UdiSdkEnvironment.this.mSseConnectCallback.onDisconnect(exc);
                }
                UdiSdkEnvironment.this.reconnectSse(handlerMap);
                UdiSdkEnvironment.this.mSuccess = false;
            }
        };
        if (this.mIsSupportBinderHttpd) {
            BinderEventHelper binderEventHelper = new BinderEventHelper(this.mBinderSocketDns, iConnectCallback);
            this.mEventHelper = binderEventHelper;
            binderEventHelper.start();
        } else {
            LocalSocketEventHelper localSocketEventHelper = new LocalSocketEventHelper(iConnectCallback);
            this.mEventHelper = localSocketEventHelper;
            localSocketEventHelper.start();
        }
        this.mEventHelper.setToken(this.mToken);
        return this.mEventHelper;
    }

    private Set<String> getEventsForHandler(IEventHandler iEventHandler) {
        if (!this.mDelayToRegister.containsKey(iEventHandler)) {
            this.mDelayToRegister.put(iEventHandler, new HashSet());
        }
        return this.mDelayToRegister.get(iEventHandler);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public synchronized void reconnectSse(Map<IEventHandler, Set<String>> map) {
        for (Map.Entry<IEventHandler, Set<String>> entry : map.entrySet()) {
            registerEvents(entry.getValue(), entry.getKey());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public synchronized void onSseConnectCreate() {
        this.mSseConnectCreate = true;
        for (Map.Entry<IEventHandler, Set<String>> entry : this.mDelayToRegister.entrySet()) {
            if (!entry.getValue().isEmpty()) {
                getEventHelper().registerEvents(entry.getValue(), entry.getKey());
            }
        }
        this.mDelayToRegister.clear();
    }

    class TokenInterceptor implements Interceptor {
        TokenInterceptor() {
        }

        @Override // okhttp3.Interceptor
        public Response intercept(Interceptor.Chain chain) throws IOException {
            Request request = chain.request();
            String strHeader = request.header("invoker");
            if (strHeader == null) {
                strHeader = UdiSdkEnvironment.this.mPackage;
            }
            if (UdiSdkEnvironment.this.mToken != null) {
                request = request.newBuilder().addHeader("token", UdiSdkEnvironment.this.mToken).addHeader("invoker", strHeader).build();
            }
            return chain.proceed(request);
        }
    }

    private static class DefaultDependentFactory implements IDependentFactory {
        private DefaultDependentFactory() {
        }

        @Override // com.ifpdos.udi.sdk.UdiSdkEnvironment.IDependentFactory
        public BinderSocketDns buildBinderSocketDns(Context context) {
            return new BinderSocketDns(context.getApplicationContext());
        }
    }
}