Merge "Less cereal, more stable"

    private static PluginManager sInstance;

    private final HandlerThread mBackgroundThread;

    private final ArrayMap<PluginListener<?>, PluginInstanceManager> mPluginMap

            = new ArrayMap<>();

    private final Map<String, ClassLoader> mClassLoaders = new ArrayMap<>();

    private ClassLoaderFilter mParentClassLoader;

    private boolean mListening;

    private boolean mHasOneShot;

    private Looper mLooper;

    public PluginManagerImpl(Context context) {

        this(context, new PluginInstanceManagerFactory(),

            UncaughtExceptionHandler defaultHandler) {

        mContext = context;

        mFactory = factory;

        mBackgroundThread = new HandlerThread("Plugins");

        mBackgroundThread.start();

        mLooper = Dependency.get(Dependency.BG_LOOPER);

        isDebuggable = debuggable;

        mPluginPrefs = new PluginPrefs(mContext);

                defaultHandler);

        Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler);

        if (isDebuggable) {

            new Handler(mBackgroundThread.getLooper()).post(() -> {

            new Handler(mLooper).post(() -> {

                // Plugin dependencies that don't have another good home can go here, but

                // dependencies that have better places to init can happen elsewhere.

                Dependency.get(PluginDependencyProvider.class)

            throw new RuntimeException("Must be called from UI thread");

        }

        PluginInstanceManager<T> p = mFactory.createPluginInstanceManager(mContext, action, null,

                false, mBackgroundThread.getLooper(), cls, this);

                false, mLooper, cls, this);

        mPluginPrefs.addAction(action);

        PluginInfo<T> info = p.getPlugin();

        if (info != null) {

        }

        mPluginPrefs.addAction(action);

        PluginInstanceManager p = mFactory.createPluginInstanceManager(mContext, action, listener,

                allowMultiple, mBackgroundThread.getLooper(), cls, this);

                allowMultiple, mLooper, cls, this);

        p.loadAll();

        mPluginMap.put(listener, p);

        startListening();

import android.support.test.annotation.UiThreadTest;

import android.support.test.runner.AndroidJUnit4;

import android.test.suitebuilder.annotation.SmallTest;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;

import android.testing.TestableLooper.RunWithLooper;

import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;

import com.android.systemui.Dependency;

import com.android.systemui.SysuiTestCase;

import com.android.systemui.plugins.annotations.ProvidesInterface;

import com.android.systemui.plugins.PluginInstanceManager.PluginInfo;

import com.android.systemui.plugins.PluginManagerImpl.PluginInstanceManagerFactory;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import java.lang.Thread.UncaughtExceptionHandler;

@SmallTest

@RunWith(AndroidJUnit4.class)

@RunWith(AndroidTestingRunner.class)

@RunWithLooper

public class PluginManagerTest extends SysuiTestCase {

    private PluginInstanceManagerFactory mMockFactory;

    @Before

    public void setup() throws Exception {

        mDependency.injectTestDependency(Dependency.BG_LOOPER,

                TestableLooper.get(this).getLooper());

        mRealExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();

        mMockExceptionHandler = mock(UncaughtExceptionHandler.class);

        mMockFactory = mock(PluginInstanceManagerFactory.class);

        mMockListener = mock(PluginListener.class);

    }

    @UiThreadTest

    @RunWithLooper(setAsMainLooper = true)

    @Test

    public void testOneShot() {

        Plugin mockPlugin = mock(Plugin.class);