Merge "Move out test utilities to a Testables library" (b40c82f2) · Commits · e / os / android_frameworks_base

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.