Back to project page AndroidPlugin.
The source code is released under:
MIT License
If you think the Android project AndroidPlugin listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2015 HouKx <hkx.aidream@gmail.com> *//from w ww. j a v a 2 s .com * 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 androidx.pluginmgr; import java.io.File; import java.io.FileFilter; import java.io.FileNotFoundException; import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import android.app.Activity; import android.app.Application; import android.app.Service; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.res.AssetManager; import android.content.res.Resources; import android.util.Log; /** * ????????? * * @author HouKangxi */ public class PluginManager implements FileFilter { private static final PluginManager instance = new PluginManager(); private Activity actFrom; private PluginManager() { } public static PluginManager getInstance(Context context) { if (instance.hasInit || context == null) { return instance; } Context ctx = context; if (context instanceof Activity) { instance.actFrom = (Activity) context; ctx = ((Activity) context).getApplication(); } else if (context instanceof Service) { ctx = ((Service) context).getApplication(); } else if (context instanceof Application) { ctx = (Application) context; } else { ctx = context.getApplicationContext(); } synchronized (PluginManager.class) { instance.init(ctx); } return instance; } static PluginManager getInstance() { return instance; } public boolean startMainActivity(Context context, String pkgOrId) { Log.d(tag, "startMainActivity by:" + pkgOrId); PlugInfo plug = preparePlugForStartActivity(context, pkgOrId); if (frameworkClassLoader == null) { Log.e(tag, "startMainActivity: frameworkClassLoader == null!"); return false; } if (plug.getMainActivity() == null) { Log.e(tag, "startMainActivity: plug.getMainActivity() == null!"); return false; } if (plug.getMainActivity().activityInfo == null) { Log.e(tag, "startMainActivity: plug.getMainActivity().activityInfo == null!"); return false; } String className = frameworkClassLoader.newActivityClassName( plug.getId(), plug.getMainActivity().activityInfo.name); context.startActivity(new Intent().setComponent(new ComponentName( context, className))); return true; } public void startActivity(Context context, Intent intent) { performStartActivity(context, intent); context.startActivity(intent); } public void startActivityForResult(Activity activity, Intent intent, int requestCode) { performStartActivity(context, intent); activity.startActivityForResult(intent, requestCode); } private PlugInfo preparePlugForStartActivity(Context context, String plugIdOrPkg) { PlugInfo plug = null; plug = getPluginByPackageName(plugIdOrPkg); if (plug == null) { plug = getPluginById(plugIdOrPkg); } if (plug == null) { throw new IllegalArgumentException("plug not found by:" + plugIdOrPkg); } return plug; } private void performStartActivity(Context context, Intent intent) { checkInit(); String plugIdOrPkg; String actName; ComponentName origComp = intent.getComponent(); if (origComp != null) { plugIdOrPkg = origComp.getPackageName(); actName = origComp.getClassName(); } else { throw new IllegalArgumentException( "plug intent must set the ComponentName!"); } PlugInfo plug = preparePlugForStartActivity(context, plugIdOrPkg); String className = frameworkClassLoader.newActivityClassName( plug.getId(), actName); Log.i(tag, "performStartActivity: " + actName); ComponentName comp = new ComponentName(context, className); intent.setAction(null); intent.setComponent(comp); } private final Map<String, PlugInfo> pluginIdToInfoMap = new ConcurrentHashMap<String, PlugInfo>(); private final Map<String, PlugInfo> pluginPkgToInfoMap = new ConcurrentHashMap<String, PlugInfo>(); private Context context; private String dexOutputPath; private volatile boolean hasInit = false; private File dexInternalStoragePath; private FrameworkClassLoader frameworkClassLoader; private PluginActivityLifeCycleCallback pluginActivityLifeCycleCallback; private static final String tag = "plugmgr"; private void init(Context ctx) { context = ctx; File optimizedDexPath = ctx.getDir("plugsout", Context.MODE_PRIVATE); if (!optimizedDexPath.exists()) { optimizedDexPath.mkdirs(); } dexOutputPath = optimizedDexPath.getAbsolutePath(); dexInternalStoragePath = context .getDir("plugins", Context.MODE_PRIVATE); dexInternalStoragePath.mkdirs(); try { Object mPackageInfo = ReflectionUtils.getFieldValue(ctx, "mBase.mPackageInfo", true); frameworkClassLoader = new FrameworkClassLoader( ctx.getClassLoader()); // set Application's classLoader to FrameworkClassLoader ReflectionUtils.setFieldValue(mPackageInfo, "mClassLoader", frameworkClassLoader, true); } catch (Exception e) { e.printStackTrace(); } hasInit = true; } private void checkInit() { if (!hasInit) { throw new IllegalStateException("PluginManager has not init!"); } } public PlugInfo getPluginById(String pluginId) { if (pluginId == null) { return null; } return pluginIdToInfoMap.get(pluginId); } public PlugInfo getPluginByPackageName(String packageName) { return pluginPkgToInfoMap.get(packageName); } public Collection<PlugInfo> getPlugins() { return pluginIdToInfoMap.values(); } public void uninstallPluginById(String pluginId) { uninstallPlugin(pluginId, true); } public void uninstallPluginByPkg(String pkg) { uninstallPlugin(pkg, false); } private void uninstallPlugin(String k, boolean isId) { checkInit(); PlugInfo pl = isId ? removePlugById(k) : removePlugByPkg(k); if (pl == null) { return; } if (context instanceof Application) { if (android.os.Build.VERSION.SDK_INT >= 14) { try { Application.class .getMethod( "unregisterComponentCallbacks", Class.forName("android.content.ComponentCallbacks")) .invoke(context, pl.getApplication()); } catch (Exception e) { e.printStackTrace(); } } } } private PlugInfo removePlugById(String pluginId) { PlugInfo pl = null; synchronized (this) { pl = pluginIdToInfoMap.remove(pluginId); if (pl == null) { return null; } pluginPkgToInfoMap.remove(pl.getPackageName()); } return pl; } private PlugInfo removePlugByPkg(String pkg) { PlugInfo pl = null; synchronized (this) { pl = pluginPkgToInfoMap.remove(pkg); if (pl == null) { return null; } pluginIdToInfoMap.remove(pl.getId()); } return pl; } /** * ????????????????????? * <p> * ??????????Id * * @param pluginSrcDirFile * - apk?apk?? * @return ???????? * @throws Exception */ public Collection<PlugInfo> loadPlugin(final File pluginSrcDirFile) throws Exception { checkInit(); if (pluginSrcDirFile == null || !pluginSrcDirFile.exists()) { Log.e(tag, "invalidate plugin file or Directory :" + pluginSrcDirFile); return null; } if (pluginSrcDirFile.isFile()) { // ???????????????????????????????apk?????????????????????,?jar PlugInfo one = loadPluginWithId(pluginSrcDirFile, null, null); return Collections.singletonList(one); } // clear all first synchronized (this) { pluginPkgToInfoMap.clear(); pluginIdToInfoMap.clear(); } File[] pluginApks = pluginSrcDirFile.listFiles(this); if (pluginApks == null || pluginApks.length < 1) { throw new FileNotFoundException("could not find plugins in:" + pluginSrcDirFile); } for (File pluginApk : pluginApks) { PlugInfo plugInfo = buildPlugInfo(pluginApk, null, null); if (plugInfo != null) { savePluginToMap(plugInfo); } } return pluginIdToInfoMap.values(); } private synchronized void savePluginToMap(PlugInfo plugInfo) { pluginPkgToInfoMap.put(plugInfo.getPackageName(), plugInfo); pluginIdToInfoMap.put(plugInfo.getId(), plugInfo); } // /** // * ????????apk <br/> // * ?????????????id <br/> // * ????????????????? // * // * @param pluginApk // * @return // * @throws Exception // */ // public PlugInfo loadPlugin(File pluginApk) throws Exception { // return loadPluginWithId(pluginApk, null, null); // } /** * ????????apk * * @param pluginApk * @param pluginId * - ???????null,??????????????id * @return * @throws Exception */ public PlugInfo loadPluginWithId(File pluginApk, String pluginId) throws Exception { return loadPluginWithId(pluginApk, pluginId, null); } public PlugInfo loadPluginWithId(File pluginApk, String pluginId, String targetFileName) throws Exception { checkInit(); PlugInfo plugInfo = buildPlugInfo(pluginApk, pluginId, targetFileName); if (plugInfo != null) { savePluginToMap(plugInfo); } return plugInfo; } private PlugInfo buildPlugInfo(File pluginApk, String pluginId, String targetFileName) throws Exception { PlugInfo info = new PlugInfo(); info.setId(pluginId == null ? pluginApk.getName() : pluginId); File privateFile = new File(dexInternalStoragePath, targetFileName == null ? pluginApk.getName() : targetFileName); info.setFilePath(privateFile.getAbsolutePath()); if (!pluginApk.getAbsolutePath().equals(privateFile.getAbsolutePath())) { copyApkToPrivatePath(pluginApk, privateFile); } String dexPath = privateFile.getAbsolutePath(); PluginManifestUtil.setManifestInfo(context, dexPath, info); PluginClassLoader loader = new PluginClassLoader(dexPath, dexOutputPath, frameworkClassLoader, info); info.setClassLoader(loader); try { AssetManager am = (AssetManager) AssetManager.class.newInstance(); am.getClass().getMethod("addAssetPath", String.class) .invoke(am, dexPath); info.setAssetManager(am); Resources ctxres = context.getResources(); Resources res = new Resources(am, ctxres.getDisplayMetrics(), ctxres.getConfiguration()); info.setResources(res); } catch (Exception e) { e.printStackTrace(); } initPluginApplication(info); // createPluginActivityProxyDexes(info); Log.i(tag, "buildPlugInfo: " + info); return info; } // private void createPluginActivityProxyDexes(PlugInfo plugin) { // { // ActInfo act = plugin.getApplicationInfo().getMainActivity(); // if (act != null) { // ActivityOverider.createProxyDex(plugin, act.name, false); // } // } // if (plugin.getApplicationInfo().getOtherActivities() != null) { // for (ActInfo act : plugin.getApplicationInfo().getOtherActivities()) // { // ActivityOverider.createProxyDex(plugin, act.name, false); // } // } // } private void initPluginApplication(final PlugInfo info) throws Exception { String className = info.getPackageInfo().applicationInfo.name; Log.d(tag, info.getId() + ", ApplicationClassName = " + className); // create Application instance for plugin if (className == null) { Application application = new Application(); setApplicationBase(info, application); } else { ClassLoader loader = info.getClassLoader(); final Class<?> applicationClass = loader.loadClass(className); if (actFrom != null) { actFrom.runOnUiThread(new Runnable() { public void run() { try { Application application = (Application) applicationClass .newInstance(); setApplicationBase(info, application); // invoke plugin application's onCreate() application.onCreate(); } catch (Throwable e) { Log.e(tag, Log.getStackTraceString(e)); } } }); } else { Application application = (Application) applicationClass .newInstance(); setApplicationBase(info, application); } } } private void setApplicationBase(PlugInfo info, Application application) throws Exception { info.setApplication(application); // PluginContextWrapper ctxWrapper = new PluginContextWrapper(context, info); // attach java.lang.reflect.Method attachMethod = android.app.Application.class .getDeclaredMethod("attach", Context.class); attachMethod.setAccessible(true); attachMethod.invoke(application, ctxWrapper); if (context instanceof Application) { if (android.os.Build.VERSION.SDK_INT >= 14) { Application.class.getMethod("registerComponentCallbacks", Class.forName("android.content.ComponentCallbacks")) .invoke(context, application); } } } private void copyApkToPrivatePath(File pluginApk, File f) { // if (f.exists() && pluginApk.length() == f.length()) { // // ??????????????????????????????????????????????? md5\sha-1 // return; // } FileUtil.copyFile(pluginApk, f); } File getDexInternalStoragePath() { return dexInternalStoragePath; } Context getContext() { return context; } public PluginActivityLifeCycleCallback getPluginActivityLifeCycleCallback() { return pluginActivityLifeCycleCallback; } public void setPluginActivityLifeCycleCallback( PluginActivityLifeCycleCallback pluginActivityLifeCycleCallback) { this.pluginActivityLifeCycleCallback = pluginActivityLifeCycleCallback; } FrameworkClassLoader getFrameworkClassLoader() { return frameworkClassLoader; } @Override public boolean accept(File pathname) { if (pathname.isDirectory()) { return false; } String fname = pathname.getName(); return fname.endsWith(".apk"); } }