前言
Small的跳转流程只不过是利用占过的坑和Uri的转换欺骗Manifest的检测，达到启动Activity的效果，Small将启动的真正的Intent放在了Category中了，然后用假的Intent通过验证后，再取出Intent的Category真正的Intent。不过跳转过程会利用到启动流程中存储的bundle信息、bundleLauncher信息、和ActivityBundleLauncher存储的宿主Activity，这里需要注意的是bundle的变量和类型理解，在前面也说有三种类型，web、lib、app，由于不同的类型会导致bundle存储的变量和类型都是有差别的，这样就导致启动的时候，执行不同的BundleLauncher的启动和跳转逻辑
跳转流程
由于app和lib的启动器都是 ApkBundleLauncher ，所以这里以 ApkBundleLauncher 为例进行说明
├── Small.openUri()
├── Bundle.getLaunchableBundle(uri)
│ └── Bundle.matchesRule()
└── Bundle.launchFrom(context)
└──ApkBundleLauncher.launchBundle()
├── ApkBundleLauncher.prelaunchBundle()
│ └── Bundle.getActivityName()
└── BundleLauncher.launchBundle()
└── Activity.startActivityForResult()
└── InstrumentationWrapper.execStartActivity()
├── InstrumentationWrapper.wrapIntent()
└── InstrumentationWrapper.dequeueStubActivity
└── InstrumentationWrapper.callActivityOnCreate
└── InstrumentationWrapper.callActivityOnStop
└── InstrumentationWrapper.callActivityOnDestroy
└── InstrumentationWrapper.onException
----------------------------------消息处理----------------------------------
├── ActivityThreadHandlerCallback.LAUNCH_ACTIVITY
└── redirectActivity()
├── ActivityThreadHandlerCallback.CREATE_SERVICE
└── ensureServiceClassesLoadable()源码分析
由于启动流程的源码比较简单，只是拿启动流程保存好的一些插件的变量进行使用，可以按照代码注释的步骤阅读
一、Small.openUri()
我们以 Small.openUri(“main”, LaunchActivity.this); 为例子，讲述它整个跳转流程
public static boolean openUri(String uriString, Context context) {
return openUri(makeUri(uriString), context);
}
//1、这里的makeUri会将"main"返回成Uri形式，http://code.wequick.net/small-sample/main
private static Uri makeUri(String uriString) {
if (!uriString.startsWith("http://")
&& !uriString.startsWith("https://")
&& !uriString.startsWith("file://")) {
uriString = sBaseUri + uriString;
}
return Uri.parse(uriString);
}
public static boolean openUri(Uri uri, Context context) {
//2、这里获取scheme = "http"
String scheme = uri.getScheme();
//3、检查是否为系统级别的Activity
if (scheme != null
&& !scheme.equals("http")
&& !scheme.equals("https")
&& !scheme.equals("file")
&& ApplicationUtils.canOpenUri(uri, context)) {
ApplicationUtils.openUri(uri, context);
return true;
}
// 4、通过当前的Uri和启动时候存储的所有插件Uri做对比，获取当前的插件
Bundle bundle = Bundle.getLaunchableBundle(uri);
if (bundle != null) {
//5、追踪这里
bundle.launchFrom(context);
return true;
}
return false;
}
protected static Bundle getLaunchableBundle(Uri uri) {
if (sPreloadBundles != null) {
for (Bundle bundle : sPreloadBundles) {
if (bundle.matchesRule(uri)) {
if (bundle.mApplicableLauncher == null) {
break;
}
if (!bundle.enabled) return null; // Illegal bundle (invalid signature, etc.)
return bundle;
}
}
}
// 由于是main插件，这里不会执行
// Downgrade to show webView
if (uri.getScheme() != null) {
Bundle bundle = new Bundle();
try {
bundle.url = new URL(uri.toString());
} catch (MalformedURLException e) {
e.printStackTrace();
}
bundle.prepareForLaunch();
bundle.setQuery(uri.getEncodedQuery()); // Fix issue #6 from Spring-Xu.
bundle.mApplicableLauncher = new WebBundleLauncher();
bundle.mApplicableLauncher.prelaunchBundle(bundle);
return bundle;
}
return null;
}
protected void launchFrom(Context context) {
if (mApplicableLauncher != null) {
//6、由于插件保存的mApplicableLauncher是ApkBundleLauncher
//所以这里就会到ApkBundleLauncher的launchBundle()
mApplicableLauncher.launchBundle(this, context);
}
}二、ApkBundleLauncher.launchBundle()
public void launchBundle(Bundle bundle, Context context) {
//7、先预加载
this.prelaunchBundle(bundle);
super.launchBundle(bundle, context);
}
@Override
publicvoid prelaunchBundle(Bundle bundle) {
super.prelaunchBundle(bundle);
Intent intent = new Intent();
bundle.setIntent(intent);
//8、获取该插件的入口Activity
String activityName = bundle.getActivityName();
//9、判断一下ActivityLauncher中的sActivityClasses是否包含该Activity，即判断是否为宿主app和Small框架里面的Activity
if (!ActivityLauncher.containsActivity(activityName)) {
//一般启动插件Activity的情况下面是会走到这里的
//sLoadedActivities 包含的是插件里面定义的Activity，在启动初始化时解析的
if (sLoadedActivities == null) {
throw new ActivityNotFoundException("Unable to find explicit activity class " +
"{ " + activityName + " }");
}
//这里表示之前启动流程的插件列表中不包括记录有当前插件的类名
if (!sLoadedActivities.containsKey(activityName)) {
if (activityName.endsWith("Activity")) {
throw new ActivityNotFoundException("Unable to find explicit activity class " +
"{ " + activityName + " }");
}
String tempActivityName = activityName + "Activity";
if (!sLoadedActivities.containsKey(tempActivityName)) {
throw new ActivityNotFoundException("Unable to find explicit activity class " +
"{ " + activityName + "(Activity) }");
}
activityName = tempActivityName;
}
}
//10、设置启动插件的ComponentName
intent.setComponent(new ComponentName(Small.getContext(), activityName));
//由于是main插件所以没有带query参数
String query = bundle.getQuery();
if (query != null) {
intent.putExtra(Small.KEY_QUERY, '?' + query);
}
}
public void launchBundle(Bundle bundle, Context context) {
if(bundle.isLaunchable()) {
if(context instanceof Activity) {
Activity activity = (Activity)context;
if(this.shouldFinishPreviousActivity(activity)) {
activity.finish();
}
//11、正常的启动插件
activity.startActivityForResult(bundle.getIntent(), 10000);
} else {
context.startActivity(bundle.getIntent());
}
}
}你以为启动插件就那么容易就启动了吗？Manifest并没有注册插件的Activity，这个时候就到了启动拦截Activity的Intent的时候
三、InstrumentationWrapper
我们都知道在启动流程中，我们已经将四大组件和资源进行了占坑和merge了，现在就是到它们工作的时候到了
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, android.os.Bundle options) {
//12、将intent 中真正的Activity替换为占坑位的Activity
wrapIntent(intent);
ensureInjectMessageHandler(sActivityThread);
return ReflectAccelerator.execStartActivity(mBase,
who, contextThread, token, target, intent, requestCode, options);
}
//这里有API版本区别21以上和20以下中的execStartActivity方法参数多了一个
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode) {
wrapIntent(intent);
ensureInjectMessageHandler(sActivityThread);
return ReflectAccelerator.execStartActivity(mBase,
who, contextThread, token, target, intent, requestCode);
}
private void wrapIntent(Intent intent) {
// 此处为插件中注册的真正的Activity
ComponentName component = intent.getComponent();
String realClazz;
if (component == null) {
// 如果component为空，交给宿主来处理这个intent
component = intent.resolveActivity(Small.getContext().getPackageManager());
if (component != null) {
// 系统或者宿主处理掉了，直接返回
return;
}
// 如果Action没有处理掉，看一下插件注册的Activity能否处理
realClazz = resolveActivity(intent);
if (realClazz == null) {
// 如果插件也不能处理，就直接返回，无能为力了……
return;
}
} else {
// 13、取出需要跳转Class
realClazz = component.getClassName();
// 如果是 PACKAGE_NAME + ".A"
if (realClazz.startsWith(STUB_ACTIVITY_PREFIX)) {
// Re-wrap to ensure the launch mode works.
// 如果这个Activity已经是占坑位的Activity，进行解开回原来的Activity
realClazz = unwrapIntent(intent);
}
}
if (sLoadedActivities == null) return;
// 14、从插件列表中获得真正Activity的信息
ActivityInfo ai = sLoadedActivities.get(realClazz);
if (ai == null) return;
// Carry the real(plugin) class for incoming `newActivity' method.
// 15、把真实的Activity放到Category中并用'>'进行标识
intent.addCategory(REDIRECT_FLAG + realClazz);
// 16、获取一个占坑位的Activity
String stubClazz = dequeueStubActivity(ai, realClazz);
// 17、将真正需要启动的Activity替换为占坑位的Activity
intent.setComponent(new ComponentName(Small.getContext(), stubClazz));
}
private static String unwrapIntent(Intent intent) {
Set<String> categories = intent.getCategories();
if (categories == null) return null;
// Get plugin activity class name from categories
// 18、遍历所有Category，找到对应的标识符，后面接的就是真实的类名
Iterator<String> it = categories.iterator();
while (it.hasNext()) {
String category = it.next();
if (category.charAt(0) == REDIRECT_FLAG) {
return category.substring(1);
}
}
return null;
}通过包装后的Intent就能欺骗过系统的检查，当我们返回的时候，就通过解包装Intent，然后在Category中获取真正的Activity，而unwrapIntent的调用时机在HandlerCallBack中
private static class ActivityThreadHandlerCallback implements Handler.Callback {
private static final int LAUNCH_ACTIVITY = 100;
private static final int CREATE_SERVICE = 114;
private static final int CONFIGURATION_CHANGED = 118;
private static final int ACTIVITY_CONFIGURATION_CHANGED = 125;
private Configuration mApplicationConfig;
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case LAUNCH_ACTIVITY:
//偷天换日 Activity
redirectActivity(msg);
break;
case CREATE_SERVICE:
ensureServiceClassesLoadable(msg);
break;
case CONFIGURATION_CHANGED:
recordConfigChanges(msg);
break;
case ACTIVITY_CONFIGURATION_CHANGED:
return relaunchActivityIfNeeded(msg);
default:
break;
}
return false;
}
private void redirectActivity(Message msg) {
Object/*ActivityClientRecord*/ r = msg.obj;
Intent intent = ReflectAccelerator.getIntent(r);
//解包装Intent
String targetClass = unwrapIntent(intent);
boolean hasSetUp = Small.hasSetUp();
if (targetClass == null) {
// 在宿主中注册的Activity
if (hasSetUp) return; // nothing to do
if (intent.hasCategory(Intent.CATEGORY_LAUNCHER)) {
// The launcher activity will setup Small.
// 带CATEGORY_LAUNCHER属性的Activity
return;
}
// Launching an activity in remote process. Set up Small for it.
Small.setUpOnDemand();
return;
}
if (!hasSetUp) {
// Restarting an activity after application recreated,
// maybe upgrading or somehow the application was killed in background.
Small.setUp();
}
// Replace with the REAL activityInfo
// 替换为真正的 activityInfo
ActivityInfo targetInfo = sLoadedActivities.get(targetClass);
ReflectAccelerator.setActivityInfo(r, targetInfo);
// Ensure the merged application-scope resource has been cached so that
// the incoming activity can attach to it without creating a new(unmerged) one.
ReflectAccelerator.ensureCacheResources();
}
}InstrumentationWrapper不仅做了欺骗Mainfest的作用，还可以用到已经Hook的Instrumentation来回调Activity的生命周期
@Override
/** Prepare resources for REAL */
public void callActivityOnCreate(Activity activity, android.os.Bundle icicle) {
do {
if (sLoadedActivities == null) break;
ActivityInfo ai = sLoadedActivities.get(activity.getClass().getName());
if (ai == null) break;
//用来设置Activity的一些转屏和键盘状态
applyActivityInfo(activity, ai);
} while (false);
// Reset activity instrumentation if it was modified by some other applications #245
if (sBundleInstrumentation != null) {
try {
Field f = Activity.class.getDeclaredField("mInstrumentation");
f.setAccessible(true);
Object instrumentation = f.get(activity);
if (instrumentation != sBundleInstrumentation) {
f.set(activity, sBundleInstrumentation);
}
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
//回调生命周期
sHostInstrumentation.callActivityOnCreate(activity, icicle);
}
@Override
public void callActivityOnSaveInstanceState(Activity activity, android.os.Bundle outState) {
sHostInstrumentation.callActivityOnSaveInstanceState(activity, outState);
if (mStubQueue != null) {
outState.putCharSequenceArray(STUB_QUEUE_RESTORE_KEY, mStubQueue);
}
}
@Override
public void callActivityOnRestoreInstanceState(Activity activity, android.os.Bundle savedInstanceState) {
sHostInstrumentation.callActivityOnRestoreInstanceState(activity, savedInstanceState);
if (mStubQueue == null) {
mStubQueue = savedInstanceState.getStringArray(STUB_QUEUE_RESTORE_KEY);
}
}
@Override
public void callActivityOnStop(Activity activity) {
//回调生命周期
sHostInstrumentation.callActivityOnStop(activity);
if (!Small.isUpgrading()) return;
// If is upgrading, we are going to kill self while application turn into background,
// and while we are back to foreground, all the things(code & layout) will be reload.
// Don't worry about the data missing in current activity, you can do all the backups
// with your activity's `onSaveInstanceState' and `onRestoreInstanceState'.
// Get all the processes of device (1)
ActivityManager am = (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> processes = am.getRunningAppProcesses();
if (processes == null) return;
// Gather all the processes of current application (2)
// Above 5.1.1, this may be equals to (1), on the safe side, we also
// filter the processes with current package name.
String pkg = activity.getApplicationContext().getPackageName();
final List<RunningAppProcessInfo> currentAppProcesses = new ArrayList<>(processes.size());
for (RunningAppProcessInfo p : processes) {
if (p.pkgList == null) continue;
boolean match = false;
int N = p.pkgList.length;
for (int i = 0; i < N; i++) {
if (p.pkgList[i].equals(pkg)) {
match = true;
break;
}
}
if (!match) continue;
currentAppProcesses.add(p);
}
if (currentAppProcesses.isEmpty()) return;
// The top process of current application processes.
RunningAppProcessInfo currentProcess = currentAppProcesses.get(0);
if (currentProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) return;
// Seems should delay some time to ensure the activity can be successfully
// restarted after the application restart.
// FIXME: remove following thread if you find the better place to `killProcess'
new Thread() {
@Override
public void run() {
try {
sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (RunningAppProcessInfo p : currentAppProcesses) {
android.os.Process.killProcess(p.pid);
}
}
}.start();
}
@Override
public void callActivityOnDestroy(Activity activity) {
do {
if (sLoadedActivities == null) break;
String realClazz = activity.getClass().getName();
ActivityInfo ai = sLoadedActivities.get(realClazz);
if (ai == null) break;
inqueueStubActivity(ai, realClazz);
} while (false);
//回调生命周期
sHostInstrumentation.callActivityOnDestroy(activity);
}Instrumentation还处理了Activity的报错，由于Small需要把插件包中的所有provider预先注册在宿主的AndroidManifest中，但是系统会在Application的onCreate生命周期执行之前根据注册的provider信息进行install，这样会导致类找不到而抛出异常，所以这里通过onException拦截当前的ClassNotFoundException并且判断如果是从方法installProvider中抛出的话我们进行捕获处理不抛出异常，把异常中的provider也就是在宿主中定义的其他插件包中的provider的类名存进数组，在后续加载完毕插件的dex和处理完classloader之后再进行install操作
@Override
public boolean onException(Object obj, Throwable e) {
if (e.getClass().equals(ClassNotFoundException.class)) {
if (sProviders == null) return super.onException(obj, e);
boolean errorOnInstallProvider = false;
StackTraceElement[] stacks = e.getStackTrace();
for (StackTraceElement st : stacks) {
if (st.getMethodName().equals("installProvider")) {
errorOnInstallProvider = true;
break;
}
}
if (errorOnInstallProvider) {
// We'll reinstall this content provider later, so just ignores it!!!
// FIXME: any better way to get the class name?
String msg = e.getMessage();
final String prefix = "Didn't find class \"";
if (msg.startsWith(prefix)) {
String providerClazz = msg.substring(prefix.length());
providerClazz = providerClazz.substring(0, providerClazz.indexOf("\""));
for (ProviderInfo info : sProviders) {
if (info.name.equals(providerClazz)) {
if (mLazyInitProviders == null) {
mLazyInitProviders = new ArrayList<ProviderInfo>();
}
mLazyInitProviders.add(info);
break;
}
}
}
return true;
}
} else if (HealthManager.fixException(obj, e)) {
return true;
}
return super.onException(obj, e);
}结语
简单的来说，Small跳转流程分为下面几步
- 简单的类型和插件的检查然后获取启动类名
- 启动前把启动类名藏起来，找一个替身Intent来帮我
- 跳到坑中，替身欺骗了系统，完成跳转
- 回调生命周期，捕捉异常
