package com.ifpdos.sdk.httpd.binder;

import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.ResolveInfo;
import android.os.IBinder;
import android.util.Log;
import com.ifpdos.sdk.httpd.binder.aidl.IServer;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/* JADX INFO: loaded from: classes.dex */
public class BinderSocketDns {
    private static final String TAG = "BinderSocketDns";
    private final Context mContext;
    private static final byte[] LOCAL_IP = {127, 0, 0, 1};
    private static final List<InetAddress> EMPTY_ADDRESS_LIST = new ArrayList();
    private final Map<String, IServer> mServers = new ConcurrentHashMap();
    private final Map<String, String> mPackages = new ConcurrentHashMap();

    public interface IServerAvailableListener {
        void onServerAvailable(String host, String pkg);
    }

    public BinderSocketDns(Context context) {
        this.mContext = context.getApplicationContext();
    }

    public void addHostPackage(String host, String pkg) {
        addHostPackage(host, pkg, null);
    }

    public void addHostPackage(String host, String pkg, IServerAvailableListener listener) {
        this.mPackages.put(host, pkg);
        IServer iServerTryPeekServiceManager = tryPeekServiceManager(new Intent(host));
        if (iServerTryPeekServiceManager != null) {
            this.mServers.put(host, iServerTryPeekServiceManager);
            if (listener != null) {
                listener.onServerAvailable(host, pkg);
            }
            Log.d(TAG, "addHostPackage: " + host + " by peekService");
            return;
        }
        if (getSystemServer(host) == null) {
            bindServer(host, listener);
        } else if (listener != null) {
            listener.onServerAvailable(host, pkg);
        }
    }

    private IServer tryPeekServiceManager(Intent service) {
        try {
            String strResolveTypeIfNeeded = service.resolveTypeIfNeeded(this.mContext.getContentResolver());
            String str = (String) this.mContext.getClass().getMethod("getOpPackageName", new Class[0]).invoke(this.mContext, new Object[0]);
            Object objInvoke = ActivityManager.class.getMethod("getService", new Class[0]).invoke(null, new Object[0]);
            IBinder iBinder = (IBinder) objInvoke.getClass().getMethod("peekService", Intent.class, String.class, String.class).invoke(objInvoke, service, strResolveTypeIfNeeded, str);
            if (iBinder == null) {
                return null;
            }
            Log.i(TAG, "peekService success");
            return IServer.Stub.asInterface(iBinder);
        } catch (Exception e) {
            Log.e(TAG, "tryPeekServiceManager error", e);
            return null;
        }
    }

    public List<InetAddress> lookup(String host) throws UnknownHostException {
        if (getServer(host) == null) {
            return EMPTY_ADDRESS_LIST;
        }
        return Collections.singletonList(InetAddress.getByAddress(host, LOCAL_IP));
    }

    public IServer getServer(String host) {
        IServer iServer = this.mServers.get(host);
        if (iServer != null && iServer.asBinder().pingBinder()) {
            return iServer;
        }
        if (iServer != null) {
            Log.d(TAG, "[" + host + "] binder died, refresh");
            this.mServers.remove(host);
        }
        IBinder systemServer = getSystemServer(host);
        if (systemServer != null) {
            Log.d(TAG, "[" + host + "] by system server");
            IServer iServerAsInterface = IServer.Stub.asInterface(systemServer);
            this.mServers.put(host, iServerAsInterface);
            return iServerAsInterface;
        }
        Log.d(TAG, "bind [" + host + "] Server");
        bindServer(host, null);
        return iServer;
    }

    private String getHostPackage(String host) {
        if (this.mPackages.containsKey(host)) {
            return this.mPackages.get(host);
        }
        List<ResolveInfo> listQueryIntentServices = this.mContext.getPackageManager().queryIntentServices(new Intent(host), 131072);
        if (listQueryIntentServices.isEmpty()) {
            return null;
        }
        return listQueryIntentServices.get(0).serviceInfo.packageName;
    }

    private void bindServer(final String host, final IServerAvailableListener listener) {
        Intent intent = new Intent(host);
        final String hostPackage = getHostPackage(host);
        intent.setPackage(hostPackage);
        this.mContext.bindService(intent, new ServiceConnection() { // from class: com.ifpdos.sdk.httpd.binder.BinderSocketDns.1
            @Override // android.content.ServiceConnection
            public void onServiceDisconnected(ComponentName name) {
            }

            @Override // android.content.ServiceConnection
            public void onServiceConnected(ComponentName name, IBinder service) {
                BinderSocketDns.this.mServers.put(host, IServer.Stub.asInterface(service));
                IServerAvailableListener iServerAvailableListener = listener;
                if (iServerAvailableListener != null) {
                    iServerAvailableListener.onServerAvailable(host, hostPackage);
                }
            }
        }, 1);
    }

    private IBinder getSystemServer(String name) {
        try {
            if (SelinuxProUtil.ignoreServiceManager()) {
                Log.d(TAG, "selinux restrictions,getService cannot be invoked and bindService is required to connect");
                return null;
            }
            return (IBinder) Class.forName("android.os.ServiceManager").getMethod("getService", String.class).invoke(null, name);
        } catch (Exception e) {
            Log.d(TAG, "getService failed", e);
            return null;
        }
    }
}