PluginManager.java 源代码

package com.x8zs.morgoo.droidplugin.pm;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PermissionGroupInfo;
import android.content.pm.PermissionInfo;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.text.TextUtils;
import com.x8zs.morgoo.droidplugin.PluginManagerService;
import com.x8zs.morgoo.droidplugin.pm.IApplicationCallback;
import com.x8zs.morgoo.droidplugin.pm.IPackageDataObserver;
import com.x8zs.morgoo.droidplugin.pm.IPluginManager;
import com.x8zs.morgoo.droidplugin.reflect.MethodUtils;
import com.x8zs.morgoo.helper.Log;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class PluginManager implements ServiceConnection {
    public static final String ACTION_DROIDPLUGIN_INIT = "com.morgoo.droidplugin.ACTION_DROIDPLUGIN_INIT";
    public static final String ACTION_MAINACTIVITY_ONCREATE = "com.morgoo.droidplugin.ACTION_MAINACTIVITY_ONCREATE";
    public static final String ACTION_MAINACTIVITY_ONDESTORY = "com.morgoo.droidplugin.ACTION_MAINACTIVITY_ONDESTORY";
    public static final String ACTION_PACKAGE_ADDED = "com.morgoo.doirplugin.PACKAGE_ADDED";
    public static final String ACTION_PACKAGE_REMOVED = "com.morgoo.doirplugin.PACKAGE_REMOVED";
    public static final String ACTION_SETTING = "com.morgoo.droidplugin.ACTION_SETTING";
    public static final String ACTION_SHORTCUT_PROXY = "com.morgoo.droidplugin.ACTION_SHORTCUT_PROXY";
    public static final String EXTRA_APP_PERSISTENT = "com.morgoo.droidplugin.EXTRA_APP_PERSISTENT";
    public static final String EXTRA_PACKAGENAME = "com.morgoo.droidplugin.EXTRA_EXTRA_PACKAGENAME";
    public static final String EXTRA_PID = "com.morgoo.droidplugin.EXTRA_PID";
    public static final int INSTALL_FAILED_NO_REQUESTEDPERMISSION = -100001;
    public static final String STUB_AUTHORITY_NAME = "com.morgoo.droidplugin_stub";
    public static final int STUB_NO_ACTIVITY_MAX_NUM = 4;
    private static final String TAG = "PluginManager";
    private static PluginManager sInstance;
    private Context mHostContext;
    private IPluginManager mPluginManager;
    private List<WeakReference<ServiceConnection>> sServiceConnection = Collections.synchronizedList(new ArrayList(1));
    private Object mWaitLock = new Object();

    public static PluginManager getInstance() {
        if (sInstance == null) {
            sInstance = new PluginManager();
        }
        return sInstance;
    }

    public void addServiceConnection(ServiceConnection serviceConnection) {
        this.sServiceConnection.add(new WeakReference<>(serviceConnection));
    }

    public int checkSignatures(String str, String str2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.checkSignatures(str, str2);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return -3;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "deletePackage", e7, new Object[0]);
            return -3;
        }
    }

    public void clearApplicationUserData(String str, final Object obj) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                iPluginManager.clearApplicationUserData(str, new IPackageDataObserver.Stub() {
                    @Override
                    public void onRemoveCompleted(String str2, boolean z6) {
                        Object obj2 = obj;
                        if (obj2 != null) {
                            try {
                                MethodUtils.invokeMethod(obj2, "onRemoveCompleted", str2, Boolean.valueOf(z6));
                            } catch (Exception unused) {
                                Throwable remoteException = new RemoteException();
                                remoteException.initCause(remoteException);
                                throw remoteException;
                            }
                        }
                    }
                });
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "clearApplicationUserData", e7, new Object[0]);
        }
    }

    public void connectToService() {
        if (this.mPluginManager == null) {
            try {
                Intent intent = new Intent(this.mHostContext, (Class<?>) PluginManagerService.class);
                intent.setPackage(this.mHostContext.getPackageName());
                this.mHostContext.startService(intent);
                this.mHostContext.bindService(intent, this, 1);
            } catch (Exception e6) {
                Log.e(TAG, "connectToService", e6, new Object[0]);
            }
        }
    }

    public void deleteApplicationCacheFiles(String str, final Object obj) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                iPluginManager.deleteApplicationCacheFiles(str, new IPackageDataObserver.Stub() {
                    @Override
                    public void onRemoveCompleted(String str2, boolean z6) {
                        Object obj2 = obj;
                        if (obj2 != null) {
                            try {
                                MethodUtils.invokeMethod(obj2, "onRemoveCompleted", str2, Boolean.valueOf(z6));
                            } catch (Exception unused) {
                                Throwable remoteException = new RemoteException();
                                remoteException.initCause(remoteException);
                                throw remoteException;
                            }
                        }
                    }
                });
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "deleteApplicationCacheFiles", e7, new Object[0]);
        }
    }

    public void deletePackage(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.deletePackage(str, i6);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "deletePackage", e7, new Object[0]);
        }
    }

    public void forceStopPackage(String str) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.forceStopPackage(str);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "forceStopPackage", e7, new Object[0]);
        }
    }

    public ActivityInfo getActivityInfo(ComponentName componentName, int i6) {
        IPluginManager iPluginManager;
        if (componentName == null) {
            return null;
        }
        try {
            iPluginManager = this.mPluginManager;
        } catch (RemoteException e6) {
            Log.e(TAG, "getActivityInfo RemoteException", e6, new Object[0]);
        } catch (Exception e7) {
            Log.e(TAG, "getActivityInfo", e7, new Object[0]);
        }
        if (iPluginManager != null) {
            return iPluginManager.getActivityInfo(componentName, i6);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return null;
    }

    public List<PermissionGroupInfo> getAllPermissionGroups(int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getAllPermissionGroups(i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getAllPermissionGroups", e7, new Object[0]);
            return null;
        }
    }

    public ApplicationInfo getApplicationInfo(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                return iPluginManager.getApplicationInfo(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            Log.e(TAG, "getApplicationInfo RemoteException", e6, new Object[0]);
            return null;
        } catch (Exception e7) {
            Log.e(TAG, "getApplicationInfo", e7, new Object[0]);
            return null;
        }
    }

    public Context getHostContext() {
        return this.mHostContext;
    }

    public List<ApplicationInfo> getInstalledApplications(int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getInstalledApplications(i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getInstalledApplications", e7, new Object[0]);
            return null;
        }
    }

    public List<PackageInfo> getInstalledPackages(int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getInstalledPackages(i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            Log.e(TAG, "getInstalledPackages RemoteException", e6, new Object[0]);
            return null;
        } catch (Exception e7) {
            Log.e(TAG, "getInstalledPackages", e7, new Object[0]);
            return null;
        }
    }

    public int getMyPid() {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getMyPid();
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return -1;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getMyPid", e7, new Object[0]);
            return -1;
        }
    }

    public PackageInfo getPackageInfo(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getPackageInfo(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getPackageInfo", e7, new Object[0]);
            return null;
        }
    }

    public List<String> getPackageNameByPid(int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getPackageNameByPid(i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "forceStopPackage", e7, new Object[0]);
            return null;
        }
    }

    public PermissionGroupInfo getPermissionGroupInfo(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                return iPluginManager.getPermissionGroupInfo(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getPermissionGroupInfo", e7, new Object[0]);
            return null;
        }
    }

    public PermissionInfo getPermissionInfo(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                return iPluginManager.getPermissionInfo(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getPermissionInfo", e7, new Object[0]);
            return null;
        }
    }

    public String getProcessNameByPid(int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getProcessNameByPid(i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "forceStopPackage", e7, new Object[0]);
            return null;
        }
    }

    public ProviderInfo getProviderInfo(ComponentName componentName, int i6) {
        IPluginManager iPluginManager;
        if (componentName == null) {
            return null;
        }
        try {
            iPluginManager = this.mPluginManager;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getProviderInfo", e7, new Object[0]);
        }
        if (iPluginManager != null) {
            return iPluginManager.getProviderInfo(componentName, i6);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return null;
    }

    public ActivityInfo getReceiverInfo(ComponentName componentName, int i6) {
        IPluginManager iPluginManager;
        if (componentName == null) {
            return null;
        }
        try {
            iPluginManager = this.mPluginManager;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getReceiverInfo", e7, new Object[0]);
        }
        if (iPluginManager != null) {
            return iPluginManager.getReceiverInfo(componentName, i6);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return null;
    }

    public List<IntentFilter> getReceiverIntentFilter(ActivityInfo activityInfo) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getReceiverIntentFilter(activityInfo);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getReceiverIntentFilter", e7, new Object[0]);
            return null;
        }
    }

    public List<ActivityInfo> getReceivers(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getReceivers(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getReceivers", e7, new Object[0]);
            return null;
        }
    }

    public ServiceInfo getServiceInfo(ComponentName componentName, int i6) {
        IPluginManager iPluginManager;
        if (componentName == null) {
            return null;
        }
        try {
            iPluginManager = this.mPluginManager;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getServiceInfo", e7, new Object[0]);
        }
        if (iPluginManager != null) {
            return iPluginManager.getServiceInfo(componentName, i6);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return null;
    }

    public ServiceInfo getTargetServiceInfo(ServiceInfo serviceInfo) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.getTargetServiceInfo(serviceInfo);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "getTargetServiceInfo", e7, new Object[0]);
            return null;
        }
    }

    public void init(Context context) {
        this.mHostContext = context;
        connectToService();
    }

    public int installPackage(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                int installPackage = iPluginManager.installPackage(str, i6);
                Log.w(TAG, String.format("%s install result %d", str, Integer.valueOf(installPackage)), new Object[0]);
                return installPackage;
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return -1;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "forceStopPackage", e7, new Object[0]);
            return -1;
        }
    }

    public boolean isConnected() {
        return (this.mHostContext == null || this.mPluginManager == null) ? false : true;
    }

    public boolean isPluginPackage(String str) {
        Context context;
        try {
            context = this.mHostContext;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "isPluginPackage", e7, new Object[0]);
        }
        if (context == null || TextUtils.equals(context.getPackageName(), str)) {
            return false;
        }
        IPluginManager iPluginManager = this.mPluginManager;
        if (iPluginManager != null && str != null) {
            return iPluginManager.isPluginPackage(str);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return false;
    }

    public boolean killApplicationProcess(String str) {
        IPluginManager iPluginManager;
        try {
            iPluginManager = this.mPluginManager;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "killApplicationProcess", e7, new Object[0]);
        }
        if (iPluginManager != null) {
            return iPluginManager.killApplicationProcess(str);
        }
        Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
        return false;
    }

    public void killBackgroundProcesses(String str) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.killBackgroundProcesses(str);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "killBackgroundProcesses", e7, new Object[0]);
        }
    }

    public void onActivityCreated(ActivityInfo activityInfo, ActivityInfo activityInfo2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onActivityCreated(activityInfo, activityInfo2);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "onActivityCreated", e7, new Object[0]);
        }
    }

    public void onActivityDestory(ActivityInfo activityInfo, ActivityInfo activityInfo2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onActivityDestory(activityInfo, activityInfo2);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "onActivityDestory", e7, new Object[0]);
        }
    }

    public void onActivtyOnNewIntent(ActivityInfo activityInfo, ActivityInfo activityInfo2, Intent intent) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onActivtyOnNewIntent(activityInfo, activityInfo2, intent);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "onActivtyOnNewIntent", e7, new Object[0]);
        }
    }

    public void onProviderCreated(ProviderInfo providerInfo, ProviderInfo providerInfo2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onProviderCreated(providerInfo, providerInfo2);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "onProviderCreated", e7, new Object[0]);
        }
    }

    @Override
    public void onServiceConnected(final ComponentName componentName, final IBinder iBinder) {
        this.mPluginManager = IPluginManager.Stub.asInterface(iBinder);
        new Thread() {
            @Override
            public void run() {
                try {
                    PluginManager.this.mPluginManager.waitForReady();
                    PluginManager.this.mPluginManager.registerApplicationCallback(new IApplicationCallback.Stub() {
                        @Override
                        public Bundle onCallback(Bundle bundle) {
                            return bundle;
                        }
                    });
                    Iterator it = PluginManager.this.sServiceConnection.iterator();
                    while (it.hasNext()) {
                        WeakReference weakReference = (WeakReference) it.next();
                        ServiceConnection serviceConnection = weakReference != null ? (ServiceConnection) weakReference.get() : null;
                        if (serviceConnection != null) {
                            serviceConnection.onServiceConnected(componentName, iBinder);
                        } else {
                            it.remove();
                        }
                    }
                    PluginManager.this.mPluginManager.asBinder().linkToDeath(new IBinder.DeathRecipient() {
                        @Override
                        public void binderDied() {
                            AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
                            PluginManager.this.onServiceDisconnected(componentName);
                        }
                    }, 0);
                    Log.i(PluginManager.TAG, "PluginManager ready!", new Object[0]);
                    try {
                        synchronized (PluginManager.this.mWaitLock) {
                            PluginManager.this.mWaitLock.notifyAll();
                        }
                    } catch (Exception e6) {
                        Log.i(PluginManager.TAG, "PluginManager notifyAll:" + e6.getMessage(), new Object[0]);
                    }
                } catch (Throwable th) {
                    try {
                        Log.e(PluginManager.TAG, "Lost the mPluginManager connect...", th, new Object[0]);
                        try {
                            synchronized (PluginManager.this.mWaitLock) {
                                PluginManager.this.mWaitLock.notifyAll();
                            }
                        } catch (Exception e7) {
                            Log.i(PluginManager.TAG, "PluginManager notifyAll:" + e7.getMessage(), new Object[0]);
                        }
                    } catch (Throwable th2) {
                        try {
                        } catch (Exception e8) {
                            Log.i(PluginManager.TAG, "PluginManager notifyAll:" + e8.getMessage(), new Object[0]);
                        }
                        synchronized (PluginManager.this.mWaitLock) {
                            PluginManager.this.mWaitLock.notifyAll();
                            throw th2;
                        }
                    }
                }
            }
        }.start();
        Log.i(TAG, "onServiceConnected connected OK!", new Object[0]);
    }

    public void onServiceCreated(ServiceInfo serviceInfo, ServiceInfo serviceInfo2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onServiceCreated(serviceInfo, serviceInfo2);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "onServiceCreated", e7, new Object[0]);
        }
    }

    public void onServiceDestory(ServiceInfo serviceInfo, ServiceInfo serviceInfo2) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.onServiceDestory(serviceInfo, serviceInfo2);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (Exception e6) {
            Log.e(TAG, "onServiceDestory", e6, new Object[0]);
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {
        ServiceConnection serviceConnection;
        Log.i(TAG, "onServiceDisconnected disconnected!", new Object[0]);
        this.mPluginManager = null;
        Iterator<WeakReference<ServiceConnection>> it = this.sServiceConnection.iterator();
        while (it.hasNext()) {
            WeakReference<ServiceConnection> next = it.next();
            if (next != null) {
                serviceConnection = next.get();
            } else {
                serviceConnection = null;
            }
            if (serviceConnection != null) {
                serviceConnection.onServiceDisconnected(componentName);
            } else {
                it.remove();
            }
        }
        connectToService();
    }

    public List<ResolveInfo> queryIntentActivities(Intent intent, String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.queryIntentActivities(intent, str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            Log.e(TAG, "queryIntentActivities RemoteException", e6, new Object[0]);
            return null;
        } catch (Exception e7) {
            Log.e(TAG, "queryIntentActivities", e7, new Object[0]);
            return null;
        }
    }

    public List<ResolveInfo> queryIntentContentProviders(Intent intent, String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.queryIntentContentProviders(intent, str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "queryIntentContentProviders", e7, new Object[0]);
            return null;
        }
    }

    public List<ResolveInfo> queryIntentReceivers(Intent intent, String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.queryIntentReceivers(intent, str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "queryIntentReceivers", e7, new Object[0]);
            return null;
        }
    }

    public List<ResolveInfo> queryIntentServices(Intent intent, String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.queryIntentServices(intent, str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            Log.e(TAG, "queryIntentServices RemoteException", e6, new Object[0]);
            return null;
        } catch (Exception e7) {
            Log.e(TAG, "queryIntentServices", e7, new Object[0]);
            return null;
        }
    }

    public List<PermissionInfo> queryPermissionsByGroup(String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                return iPluginManager.queryPermissionsByGroup(str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "queryPermissionsByGroup", e7, new Object[0]);
            return null;
        }
    }

    public void removeServiceConnection(ServiceConnection serviceConnection) {
        Iterator<WeakReference<ServiceConnection>> it = this.sServiceConnection.iterator();
        while (it.hasNext()) {
            if (it.next().get() == serviceConnection) {
                it.remove();
            }
        }
    }

    public void reportMyProcessName(String str, String str2, String str3) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                iPluginManager.reportMyProcessName(str, str2, str3);
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "reportMyProcessName", e7, new Object[0]);
        }
    }

    public ActivityInfo resolveActivityInfo(Intent intent, int i6) {
        ActivityInfo activityInfo;
        try {
            if (this.mPluginManager != null) {
                if (intent.getComponent() != null) {
                    return this.mPluginManager.getActivityInfo(intent.getComponent(), i6);
                }
                ResolveInfo resolveIntent = this.mPluginManager.resolveIntent(intent, intent.resolveTypeIfNeeded(this.mHostContext.getContentResolver()), i6);
                if (resolveIntent != null && (activityInfo = resolveIntent.activityInfo) != null) {
                    return activityInfo;
                }
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubActivityInfo", e7, new Object[0]);
            return null;
        }
    }

    public ProviderInfo resolveContentProvider(String str, Integer num) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && str != null) {
                return iPluginManager.resolveContentProvider(str, num.intValue());
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "resolveContentProvider", e7, new Object[0]);
            return null;
        }
    }

    public ResolveInfo resolveIntent(Intent intent, String str, int i6) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.resolveIntent(intent, str, i6);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "resolveIntent", e7, new Object[0]);
            return null;
        }
    }

    public ResolveInfo resolveService(Intent intent, String str, Integer num) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null && intent != null) {
                return iPluginManager.resolveService(intent, str, num.intValue());
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "resolveService", e7, new Object[0]);
            return null;
        }
    }

    public ServiceInfo resolveServiceInfo(Intent intent, int i6) {
        ServiceInfo serviceInfo;
        try {
            if (this.mPluginManager != null) {
                if (intent.getComponent() != null) {
                    return this.mPluginManager.getServiceInfo(intent.getComponent(), i6);
                }
                ResolveInfo resolveIntent = this.mPluginManager.resolveIntent(intent, intent.resolveTypeIfNeeded(this.mHostContext.getContentResolver()), i6);
                if (resolveIntent != null && (serviceInfo = resolveIntent.serviceInfo) != null) {
                    return serviceInfo;
                }
            } else {
                Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            }
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "resolveServiceInfo", e7, new Object[0]);
            return null;
        }
    }

    public ActivityInfo selectStubActivityInfo(ActivityInfo activityInfo) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.selectStubActivityInfo(activityInfo);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubActivityInfo", e7, new Object[0]);
            return null;
        }
    }

    public ProviderInfo selectStubProviderInfo(String str) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.selectStubProviderInfo(str);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubProviderInfo", e7, new Object[0]);
            return null;
        }
    }

    public ServiceInfo selectStubServiceInfo(ServiceInfo serviceInfo) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.selectStubServiceInfo(serviceInfo);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubServiceInfo", e7, new Object[0]);
            return null;
        }
    }

    public void waitForConnected() {
        if (isConnected()) {
            return;
        }
        try {
            synchronized (this.mWaitLock) {
                this.mWaitLock.wait();
            }
        } catch (InterruptedException e6) {
            Log.i(TAG, "waitForConnected:" + e6.getMessage(), new Object[0]);
        }
        Log.i(TAG, "waitForConnected finish", new Object[0]);
    }

    public ActivityInfo selectStubActivityInfo(Intent intent) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.selectStubActivityInfoByIntent(intent);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubActivityInfo", e7, new Object[0]);
            return null;
        }
    }

    public ServiceInfo selectStubServiceInfo(Intent intent) {
        try {
            IPluginManager iPluginManager = this.mPluginManager;
            if (iPluginManager != null) {
                return iPluginManager.selectStubServiceInfoByIntent(intent);
            }
            Log.w(TAG, "Plugin Package Manager Service not be connect", new Object[0]);
            return null;
        } catch (RemoteException e6) {
            throw e6;
        } catch (Exception e7) {
            Log.e(TAG, "selectStubServiceInfo", e7, new Object[0]);
            return null;
        }
    }

    public void waitForConnected(long j6) {
        if (j6 > 0) {
            if (isConnected()) {
                return;
            }
            try {
                synchronized (this.mWaitLock) {
                    this.mWaitLock.wait(j6);
                }
            } catch (InterruptedException e6) {
                Log.i(TAG, "waitForConnected:" + e6.getMessage(), new Object[0]);
            }
            Log.i(TAG, "waitForConnected finish", new Object[0]);
            return;
        }
        waitForConnected();
    }

    public boolean isPluginPackage(ComponentName componentName) {
        if (componentName == null) {
            return false;
        }
        return isPluginPackage(componentName.getPackageName());
    }
}