/* * Copyright (C) 2016 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 * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the specific language governing * permissions and limitations under the License. */ package com.android.systemui.shared.plugins; import android.app.NotificationManager; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.net.Uri; import android.os.Build; import android.os.SystemProperties; import android.util.ArrayMap; import android.util.ArraySet; import android.util.Log; import android.widget.Toast; import com.android.internal.messages.nano.SystemMessageProto.SystemMessage; import com.android.systemui.plugins.Plugin; import com.android.systemui.plugins.PluginListener; import java.io.FileDescriptor; import java.io.PrintWriter; import java.lang.Thread.UncaughtExceptionHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.List; import java.util.Map; import java.util.Optional; /** * @see Plugin */ public class PluginManagerImpl extends BroadcastReceiver implements PluginManager { private static final String TAG = PluginManagerImpl.class.getSimpleName(); static final String DISABLE_PLUGIN = "com.android.systemui.action.DISABLE_PLUGIN"; private final ArrayMap, PluginActionManager> mPluginMap = new ArrayMap<>(); private final Map mClassLoaders = new ArrayMap<>(); private final ArraySet mPrivilegedPlugins = new ArraySet<>(); private final Context mContext; private final PluginActionManager.Factory mActionManagerFactory; private final boolean mIsDebuggable; private final PluginPrefs mPluginPrefs; private final PluginEnabler mPluginEnabler; private boolean mListening; public PluginManagerImpl(Context context, PluginActionManager.Factory actionManagerFactory, boolean debuggable, Optional defaultHandlerOptional, PluginEnabler pluginEnabler, PluginPrefs pluginPrefs, List privilegedPlugins) { mContext = context; mActionManagerFactory = actionManagerFactory; mIsDebuggable = debuggable; mPrivilegedPlugins.addAll(privilegedPlugins); mPluginPrefs = pluginPrefs; mPluginEnabler = pluginEnabler; PluginExceptionHandler uncaughtExceptionHandler = new PluginExceptionHandler( defaultHandlerOptional); invoke(sSetUncaughtExceptionPreHandler, null, uncaughtExceptionHandler); } public boolean isDebuggable() { return mIsDebuggable; } public String[] getPrivilegedPlugins() { return mPrivilegedPlugins.toArray(new String[0]); } /** */ public void addPluginListener(PluginListener listener, Class cls) { addPluginListener(listener, cls, false); } /** */ public void addPluginListener(PluginListener listener, Class cls, boolean allowMultiple) { addPluginListener(PluginManager.Helper.getAction(cls), listener, cls, allowMultiple); } public void addPluginListener(String action, PluginListener listener, Class cls) { addPluginListener(action, listener, cls, false); } public void addPluginListener(String action, PluginListener listener, Class cls, boolean allowMultiple) { mPluginPrefs.addAction(action); PluginActionManager p = mActionManagerFactory.create(action, listener, cls, allowMultiple, isDebuggable()); p.loadAll(); synchronized (this) { mPluginMap.put(listener, p); } startListening(); } public void removePluginListener(PluginListener listener) { synchronized (this) { if (!mPluginMap.containsKey(listener)) { return; } mPluginMap.remove(listener).destroy(); if (mPluginMap.size() == 0) { 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_REPLACED); filter.addAction(Intent.ACTION_PACKAGE_REMOVED); filter.addDataScheme("package"); mContext.registerReceiver(this, filter); filter.addAction(PLUGIN_CHANGED); filter.addAction(DISABLE_PLUGIN); filter.addDataScheme("package"); mContext.registerReceiver(this, filter, PluginActionManager.PLUGIN_PERMISSION, null); filter = new IntentFilter(Intent.ACTION_USER_UNLOCKED); mContext.registerReceiver(this, filter); } private void stopListening() { if (!mListening) return; mListening = false; mContext.unregisterReceiver(this); } @Override public void onReceive(Context context, Intent intent) { if (Intent.ACTION_USER_UNLOCKED.equals(intent.getAction())) { synchronized (this) { for (PluginActionManager manager : mPluginMap.values()) { manager.loadAll(); } } } else if (DISABLE_PLUGIN.equals(intent.getAction())) { Uri uri = intent.getData(); ComponentName component = ComponentName.unflattenFromString( uri.toString().substring(10)); if (isPluginPrivileged(component)) { // Don't disable privileged plugins as they are a part of the OS. return; } mPluginEnabler.setDisabled(component, PluginEnabler.DISABLED_INVALID_VERSION); mContext.getSystemService(NotificationManager.class).cancel(component.getClassName(), SystemMessage.NOTE_PLUGIN); } else { Uri data = intent.getData(); String pkg = data.getEncodedSchemeSpecificPart(); ComponentName componentName = ComponentName.unflattenFromString(pkg); if (clearClassLoader(pkg)) { if (Build.IS_ENG) { Toast.makeText(mContext, "Reloading " + pkg, Toast.LENGTH_LONG).show(); } else { Log.v(TAG, "Reloading " + pkg); } } if (Intent.ACTION_PACKAGE_REPLACED.equals(intent.getAction()) && componentName != null) { @PluginEnabler.DisableReason int disableReason = mPluginEnabler.getDisableReason(componentName); if (disableReason == PluginEnabler.DISABLED_FROM_EXPLICIT_CRASH || disableReason == PluginEnabler.DISABLED_FROM_SYSTEM_CRASH || disableReason == PluginEnabler.DISABLED_INVALID_VERSION) { Log.i(TAG, "Re-enabling previously disabled plugin that has been " + "updated: " + componentName.flattenToShortString()); mPluginEnabler.setEnabled(componentName); } } synchronized (this) { if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction()) || Intent.ACTION_PACKAGE_CHANGED.equals(intent.getAction()) || Intent.ACTION_PACKAGE_REPLACED.equals(intent.getAction())) { for (PluginActionManager actionManager : mPluginMap.values()) { actionManager.reloadPackage(pkg); } } else { for (PluginActionManager manager : mPluginMap.values()) { manager.onPackageRemoved(pkg); } } } } } private boolean clearClassLoader(String pkg) { return mClassLoaders.remove(pkg) != null; } public boolean dependsOn(Plugin p, Class cls) { synchronized (this) { for (int i = 0; i < mPluginMap.size(); i++) { if (mPluginMap.valueAt(i).dependsOn(p, cls)) { return true; } } } return false; } public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { synchronized (this) { pw.println(String.format(" plugin map (%d):", mPluginMap.size())); for (PluginListener listener : mPluginMap.keySet()) { pw.println(String.format(" %s -> %s", listener, mPluginMap.get(listener))); } } } private boolean isPluginPrivileged(ComponentName pluginName) { for (String componentNameOrPackage : mPrivilegedPlugins) { ComponentName componentName = ComponentName.unflattenFromString(componentNameOrPackage); if (componentName != null) { if (componentName.equals(pluginName)) { return true; } } else if (componentNameOrPackage.equals(pluginName.getPackageName())) { return true; } } return false; } // This allows plugins to include any libraries or copied code they want by only including // classes from the plugin library. 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 Optional mExceptionHandlerOptional; private PluginExceptionHandler( Optional exceptionHandlerOptional) { mExceptionHandlerOptional = exceptionHandlerOptional; } @Override public void uncaughtException(Thread thread, Throwable throwable) { if (SystemProperties.getBoolean("plugin.debugging", false)) { Throwable finalThrowable = throwable; mExceptionHandlerOptional.ifPresent( handler -> handler.uncaughtException(thread, finalThrowable)); 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. synchronized (this) { for (PluginActionManager manager : mPluginMap.values()) { disabledAny |= manager.disableAll(); } } } if (disabledAny) { throwable = new CrashWhilePluginActiveException(throwable); } // Run the normal exception handler so we can crash and cleanup our state. Throwable finalThrowable = throwable; mExceptionHandlerOptional.ifPresent( handler -> handler.uncaughtException(thread, finalThrowable)); } private boolean checkStack(Throwable throwable) { if (throwable == null) return false; boolean disabledAny = false; synchronized (this) { for (StackTraceElement element : throwable.getStackTrace()) { for (PluginActionManager manager : mPluginMap.values()) { disabledAny |= manager.checkAndDisable(element.getClassName()); } } } return disabledAny | checkStack(throwable.getCause()); } } public static class CrashWhilePluginActiveException extends RuntimeException { public CrashWhilePluginActiveException(Throwable throwable) { super(throwable); } } private static Method sSetUncaughtExceptionPreHandler; static { try { Method getDeclaredMethod = Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class); sSetUncaughtExceptionPreHandler = (Method) getDeclaredMethod.invoke(Thread.class, "setUncaughtExceptionPreHandler", new Class[]{UncaughtExceptionHandler.class}); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } } private static Object invoke(Method method, Object obj, Object... args) { try { return method.invoke(obj, args); } catch (IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); return null; } } }