Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 340b0e52 authored by Jason Monk's avatar Jason Monk
Browse files

Move out test utilities to a Testables library 

Test: runtest --path frameworks/base/tests/testablets/tests
        && runtest systemui

Change-Id: Ideef4aef5f26136b1741c556b9be5884f38842a0
parent 2ffca839

packages/SystemUI/src/com/android/systemui/Dependency.java

+4 −2
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ import com.android.systemui.fragments.FragmentService; 
import com.android.systemui.plugins.ActivityStarter;

import com.android.systemui.plugins.PluginDependencyProvider;

import com.android.systemui.plugins.PluginManager;

import com.android.systemui.plugins.PluginManagerImpl;

import com.android.systemui.statusbar.phone.ConfigurationControllerImpl;

import com.android.systemui.statusbar.phone.DarkIconDispatcherImpl;

import com.android.systemui.statusbar.phone.ManagedProfileController;
@@ -73,6 +74,7 @@ import com.android.systemui.statusbar.policy.UserSwitcherController; 
import com.android.systemui.statusbar.policy.ZenModeController;

import com.android.systemui.statusbar.policy.ZenModeControllerImpl;

import com.android.systemui.tuner.TunerService;

import com.android.systemui.tuner.TunerServiceImpl;

import com.android.systemui.util.leak.GarbageMonitor;

import com.android.systemui.util.leak.LeakDetector;

import com.android.systemui.util.leak.LeakReporter;
@@ -200,7 +202,7 @@ public class Dependency extends SystemUI { 
                new DeviceProvisionedControllerImpl(mContext));



        mProviders.put(PluginManager.class, () ->

                new PluginManager(mContext));

                new PluginManagerImpl(mContext));



        mProviders.put(AssistManager.class, () ->

                new AssistManager(getDependency(DeviceProvisionedController.class), mContext));
@@ -223,7 +225,7 @@ public class Dependency extends SystemUI { 
                getDependency(LeakReporter.class)));



        mProviders.put(TunerService.class, () ->

                new TunerService(mContext));

                new TunerServiceImpl(mContext));



        mProviders.put(StatusBarWindowManager.class, () ->

                new StatusBarWindowManager(mContext));

packages/SystemUI/src/com/android/systemui/plugins/PluginInstanceManager.java

+4 −4
Original line number Diff line number Diff line
@@ -62,10 +62,10 @@ public class PluginInstanceManager<T extends Plugin> { 
    final PluginHandler mPluginHandler;

    private final boolean isDebuggable;

    private final PackageManager mPm;

    private final PluginManager mManager;

    private final PluginManagerImpl mManager;



    PluginInstanceManager(Context context, String action, PluginListener<T> listener,

            boolean allowMultiple, Looper looper, VersionInfo version, PluginManager manager) {

            boolean allowMultiple, Looper looper, VersionInfo version, PluginManagerImpl manager) {

        this(context, context.getPackageManager(), action, listener, allowMultiple, looper, version,

                manager, Build.IS_DEBUGGABLE);

    }
@@ -73,7 +73,7 @@ public class PluginInstanceManager<T extends Plugin> { 
    @VisibleForTesting

    PluginInstanceManager(Context context, PackageManager pm, String action,

            PluginListener<T> listener, boolean allowMultiple, Looper looper, VersionInfo version,

            PluginManager manager, boolean debuggable) {

            PluginManagerImpl manager, boolean debuggable) {

        mMainHandler = new MainHandler(Looper.getMainLooper());

        mPluginHandler = new PluginHandler(looper);

        mManager = manager;
@@ -346,7 +346,7 @@ public class PluginInstanceManager<T extends Plugin> { 
                                .setContentText("Check to see if an OTA is available.\n"

                                        + e.getMessage());

                    }

                    Intent i = new Intent(PluginManager.DISABLE_PLUGIN).setData(

                    Intent i = new Intent(PluginManagerImpl.DISABLE_PLUGIN).setData(

                            Uri.parse("package://" + component.flattenToString()));

                    PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, i, 0);

                    nb.addAction(new Action.Builder(null, "Disable plugin", pi).build());

packages/SystemUI/src/com/android/systemui/plugins/PluginManager.java

+16 −337
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file

 * except in compliance with the License. You may obtain a copy of the License at
@@ -14,276 +14,33 @@ 


package com.android.systemui.plugins;



import android.app.Notification;

import android.app.Notification.Action;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.ComponentName;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageManager;

import android.content.pm.PackageManager.NameNotFoundException;

import android.content.res.Resources;

import android.net.Uri;

import android.os.Build;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.Looper;

import android.os.SystemProperties;

import android.os.UserHandle;

import android.text.TextUtils;

import android.util.ArrayMap;

import android.util.ArraySet;



import com.android.internal.annotations.VisibleForTesting;

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

import com.android.systemui.Dependency;

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

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

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



import dalvik.system.PathClassLoader;

public interface PluginManager {



import java.lang.Thread.UncaughtExceptionHandler;

import java.util.Map;



/**

 * @see Plugin

 */

public class PluginManager extends BroadcastReceiver {



    public static final String PLUGIN_CHANGED = "com.android.systemui.action.PLUGIN_CHANGED";



    static final String DISABLE_PLUGIN = "com.android.systemui.action.DISABLE_PLUGIN";

    String PLUGIN_CHANGED = "com.android.systemui.action.PLUGIN_CHANGED";



    // must be one of the channels created in NotificationChannels.java

    static final String NOTIFICATION_CHANNEL_ID = "ALR";



    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 final ArraySet<String> mOneShotPackages = new ArraySet<>();

    private final Context mContext;

    private final PluginInstanceManagerFactory mFactory;

    private final boolean isDebuggable;

    private final PluginPrefs mPluginPrefs;

    private ClassLoaderFilter mParentClassLoader;

    private boolean mListening;

    private boolean mHasOneShot;



    public PluginManager(Context context) {

        this(context, new PluginInstanceManagerFactory(),

                Build.IS_DEBUGGABLE, Thread.getDefaultUncaughtExceptionHandler());

    }



    @VisibleForTesting

    PluginManager(Context context, PluginInstanceManagerFactory factory, boolean debuggable,

            UncaughtExceptionHandler defaultHandler) {

        mContext = context;

        mFactory = factory;

        mBackgroundThread = new HandlerThread("Plugins");

        mBackgroundThread.start();

        isDebuggable = debuggable;

        mPluginPrefs = new PluginPrefs(mContext);



        PluginExceptionHandler uncaughtExceptionHandler = new PluginExceptionHandler(

                defaultHandler);

        Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler);

        if (isDebuggable) {

            new Handler(mBackgroundThread.getLooper()).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)

                        .allowPluginDependency(ActivityStarter.class);

            });

        }

    }



    public <T extends Plugin> T getOneShotPlugin(Class<T> cls) {

        ProvidesInterface info = cls.getDeclaredAnnotation(ProvidesInterface.class);

        if (info == null) {

            throw new RuntimeException(cls + " doesn't provide an interface");

        }

        if (TextUtils.isEmpty(info.action())) {

            throw new RuntimeException(cls + " doesn't provide an action");

        }

        return getOneShotPlugin(info.action(), cls);

    }



    public <T extends Plugin> T getOneShotPlugin(String action, Class<?> cls) {

        if (!isDebuggable) {

            // Never ever ever allow these on production builds, they are only for prototyping.

            return null;

        }

        if (Looper.myLooper() != Looper.getMainLooper()) {

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

        }

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

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

        mPluginPrefs.addAction(action);

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

        if (info != null) {

            mOneShotPackages.add(info.mPackage);

            mHasOneShot = true;

            startListening();

            return info.mPlugin;

        }

        return null;

    }



    public <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls) {

        addPluginListener(listener, cls, false);

    }



    public <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls,

            boolean allowMultiple) {

        addPluginListener(getAction(cls), listener, cls, allowMultiple);

    }



    public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,

            Class<?> cls) {

        addPluginListener(action, listener, cls, false);

    }



    public <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,

            Class cls, boolean allowMultiple) {

        if (!isDebuggable) {

            // Never ever ever allow these on production builds, they are only for prototyping.

            return;

        }

        mPluginPrefs.addAction(action);

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

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

        p.loadAll();

        mPluginMap.put(listener, p);

        startListening();

    }



    public void removePluginListener(PluginListener<?> listener) {

        if (!isDebuggable) {

            // Never ever ever allow these on production builds, they are only for prototyping.

            return;

        }

        if (!mPluginMap.containsKey(listener)) return;

        mPluginMap.remove(listener).destroy();

        stopListening();

    }



    private void startListening() {

        if (mListening) return;

        mListening = true;

        IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);

        filter.addAction(Intent.ACTION_PACKAGE_CHANGED);

        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);

        filter.addAction(PLUGIN_CHANGED);

        filter.addAction(DISABLE_PLUGIN);

        filter.addDataScheme("package");

        mContext.registerReceiver(this, filter);

        filter = new IntentFilter(Intent.ACTION_USER_UNLOCKED);

        mContext.registerReceiver(this, filter);

    }



    private void stopListening() {

        // Never stop listening if a one-shot is present.

        if (!mListening || mHasOneShot) return;

        mListening = false;

        mContext.unregisterReceiver(this);

    }

    String NOTIFICATION_CHANNEL_ID = "ALR";



    @Override

    public void onReceive(Context context, Intent intent) {

        if (Intent.ACTION_USER_UNLOCKED.equals(intent.getAction())) {

            for (PluginInstanceManager manager : mPluginMap.values()) {

                manager.loadAll();

            }

        } else if (DISABLE_PLUGIN.equals(intent.getAction())) {

            Uri uri = intent.getData();

            ComponentName component = ComponentName.unflattenFromString(

                    uri.toString().substring(10));

            mContext.getPackageManager().setComponentEnabledSetting(component,

                    PackageManager.COMPONENT_ENABLED_STATE_DISABLED,

                    PackageManager.DONT_KILL_APP);

            mContext.getSystemService(NotificationManager.class).cancel(component.getClassName(),

                    SystemMessage.NOTE_PLUGIN);

        } else {

            Uri data = intent.getData();

            String pkg = data.getEncodedSchemeSpecificPart();

            if (mOneShotPackages.contains(pkg)) {

                int icon = mContext.getResources().getIdentifier("tuner", "drawable",

                        mContext.getPackageName());

                int color = Resources.getSystem().getIdentifier(

                        "system_notification_accent_color", "color", "android");

                String label = pkg;

                try {

                    PackageManager pm = mContext.getPackageManager();

                    label = pm.getApplicationInfo(pkg, 0).loadLabel(pm).toString();

                } catch (NameNotFoundException e) {

                }

                // Localization not required as this will never ever appear in a user build.

                final Notification.Builder nb =

                        new Notification.Builder(mContext, NOTIFICATION_CHANNEL_ID)

                                .setSmallIcon(icon)

                                .setWhen(0)

                                .setShowWhen(false)

                                .setPriority(Notification.PRIORITY_MAX)

                                .setVisibility(Notification.VISIBILITY_PUBLIC)

                                .setColor(mContext.getColor(color))

                                .setContentTitle("Plugin \"" + label + "\" has updated")

                                .setContentText("Restart SysUI for changes to take effect.");

                Intent i = new Intent("com.android.systemui.action.RESTART").setData(

                            Uri.parse("package://" + pkg));

                PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, i, 0);

                nb.addAction(new Action.Builder(null, "Restart SysUI", pi).build());

                mContext.getSystemService(NotificationManager.class).notifyAsUser(pkg,

                        SystemMessage.NOTE_PLUGIN, nb.build(), UserHandle.ALL);

            }

            clearClassLoader(pkg);

            if (!Intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction())) {

                for (PluginInstanceManager manager : mPluginMap.values()) {

                    manager.onPackageChange(pkg);

                }

            } else {

                for (PluginInstanceManager manager : mPluginMap.values()) {

                    manager.onPackageRemoved(pkg);

                }

            }

        }

    }

    <T extends Plugin> T getOneShotPlugin(Class<T> cls);

    <T extends Plugin> T getOneShotPlugin(String action, Class<?> cls);



    public ClassLoader getClassLoader(String sourceDir, String pkg) {

        if (mClassLoaders.containsKey(pkg)) {

            return mClassLoaders.get(pkg);

        }

        ClassLoader classLoader = new PathClassLoader(sourceDir, getParentClassLoader());

        mClassLoaders.put(pkg, classLoader);

        return classLoader;

    }

    <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls);

    <T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<?> cls,

            boolean allowMultiple);

    <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,

            Class<?> cls);

    <T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,

            Class cls, boolean allowMultiple);



    private void clearClassLoader(String pkg) {

        mClassLoaders.remove(pkg);

    }

    void removePluginListener(PluginListener<?> listener);



    ClassLoader getParentClassLoader() {

        if (mParentClassLoader == null) {

            // Lazily load this so it doesn't have any effect on devices without plugins.

            mParentClassLoader = new ClassLoaderFilter(getClass().getClassLoader(),

                    "com.android.systemui.plugin");

        }

        return mParentClassLoader;

    }

    <T> boolean dependsOn(Plugin p, Class<T> cls);



    public Context getContext(ApplicationInfo info, String pkg) throws NameNotFoundException {

        ClassLoader classLoader = getClassLoader(info.sourceDir, pkg);

        return new PluginContextWrapper(mContext.createApplicationContext(info, 0), classLoader);

    }



    public static <P> String getAction(Class<P> cls) {

    static <P> String getAction(Class<P> cls) {

        ProvidesInterface info = cls.getDeclaredAnnotation(ProvidesInterface.class);

        if (info == null) {

            throw new RuntimeException(cls + " doesn't provide an interface");
@@ -293,82 +50,4 @@ public class PluginManager extends BroadcastReceiver { 
        }

        return info.action();

    }



    public <T> boolean dependsOn(Plugin p, Class<T> cls) {

        for (int i = 0; i < mPluginMap.size(); i++) {

            if (mPluginMap.valueAt(i).dependsOn(p, cls)) {

                return true;

            }

        }

        return false;

    }



    @VisibleForTesting

    public static class PluginInstanceManagerFactory {

        public <T extends Plugin> PluginInstanceManager createPluginInstanceManager(Context context,

                String action, PluginListener<T> listener, boolean allowMultiple, Looper looper,

                Class<?> cls, PluginManager manager) {

            return new PluginInstanceManager(context, action, listener, allowMultiple, looper,

                    new VersionInfo().addClass(cls), manager);

        }

    }



    // This allows plugins to include any libraries or copied code they want by only including

    // classes from the plugin library.

    private static class ClassLoaderFilter extends ClassLoader {

        private final String mPackage;

        private final ClassLoader mBase;



        public ClassLoaderFilter(ClassLoader base, String pkg) {

            super(ClassLoader.getSystemClassLoader());

            mBase = base;

            mPackage = pkg;

        }



        @Override

        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {

            if (!name.startsWith(mPackage)) super.loadClass(name, resolve);

            return mBase.loadClass(name);

        }

    }



    private class PluginExceptionHandler implements UncaughtExceptionHandler {

        private final UncaughtExceptionHandler mHandler;



        private PluginExceptionHandler(UncaughtExceptionHandler handler) {

            mHandler = handler;

        }



        @Override

        public void uncaughtException(Thread thread, Throwable throwable) {

            if (SystemProperties.getBoolean("plugin.debugging", false)) {

                mHandler.uncaughtException(thread, throwable);

                return;

            }

            // Search for and disable plugins that may have been involved in this crash.

            boolean disabledAny = checkStack(throwable);

            if (!disabledAny) {

                // We couldn't find any plugins involved in this crash, just to be safe

                // disable all the plugins, so we can be sure that SysUI is running as

                // best as possible.

                for (PluginInstanceManager manager : mPluginMap.values()) {

                    manager.disableAll();

                }

            }



            // Run the normal exception handler so we can crash and cleanup our state.

            mHandler.uncaughtException(thread, throwable);

        }



        private boolean checkStack(Throwable throwable) {

            if (throwable == null) return false;

            boolean disabledAny = false;

            for (StackTraceElement element : throwable.getStackTrace()) {

                for (PluginInstanceManager manager : mPluginMap.values()) {

                    disabledAny |= manager.checkAndDisable(element.getClassName());

                }

            }

            return disabledAny | checkStack(throwable.getCause());

        }

    }

}

packages/SystemUI/src/com/android/systemui/plugins/PluginManagerImpl.java

0 → 100644
+358 −0

File added.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/systemui/tuner/TunerService.java

+46 −233

File changed.

Preview size limit exceeded, changes collapsed.