首页 > 代码库 > 深入分析Intent匹配查询
深入分析Intent匹配查询
尊重原创：http://blog.csdn.net/yuanzeyao/article/details/42243583
在前面的一篇文章中，我们详细分析了PackageManagerService的启动过程(在后面的文章中，为了方便，我会将PackageManagerService简称PMS)，PMS在启动的过程中，会去扫描系统app和用户安装的app，然后将这些app的信息保存到一些数据结构中，在这篇文章中，我们会接着前面一篇文章继续分析Intent匹配查询过程，如果对PMS不是很熟悉的同学建议先去阅读前面一篇文章PackageManagerService启动过程分析。
作为一名Android App开发着，我相信你对Intent的使用是再熟悉不过了，例如我想在一个Activity中启动另外一个Activity,会使用如下代码：
Intent intent=new Intent(this,SecondActivity.class); this.startActivity(intent);
以上方式称为显示Intent调用，当然有些时候我们会使用隐式Intent，例如：
Intent intent=new Intent("com.android.demo");
this.startActivity(intent);由于Intent的使用非常简单，所以在这里我不想再去花太多时间去描述它了，我们这里是要从源码的角度去理解通过Intent是如何匹配Acitivity的(Service,Receiver原理也是差不多的)。
我们直接从startActivity函数开始吧(提示：我使用的是4.1源码，不同版本的源码会有些出入)，在这里，先给出一张时序图，然后跟着时序图看源码。
图1-1
根据图1-1，当我们调用Activity的startActivity方法时，其实调用的就是调用ContextImpl的startActivity方法
public void startActivity(Intent intent, Bundle options) {
if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
throw new AndroidRuntimeException(
"Calling startActivity() from outside of an Activity "
+ " context requires the FLAG_ACTIVITY_NEW_TASK flag."
+ " Is this really what you want?");
}
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity)null, intent, -1, options);
}在ContextImple的startActivity方法中，会调用Instrumentation的execStartActivity方法，这个方法我就不贴出源码了，它里面其实就是调用了ActivityManagerService的startActivity方法，这个方法里面其实就是调用了ActivityStack的startActivityMayWait方法，该方法又调用了自身的resolveActivity方法，最后调用了PMS的resolveIntent方法了，到这里终于见到了PMS了，在resolveIntent方法里面就是调用了自身的queryIntentActivities方法，queryIntentActivities会返回一个ActivityInfo对象，我们知道一个ActivityInfo对象就是一个Activity的档案对象，记录了一个Acitivity的所有的信息。这里给出queryIntentActivities的源码
public List<ResolveInfo> queryIntentActivities(Intent intent,
String resolvedType, int flags, int userId) {
if (!sUserManager.exists(userId)) return null;
ComponentName comp = intent.getComponent();
if (comp == null) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
comp = intent.getComponent();
}
}
if (comp != null) {
final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
final ActivityInfo ai = getActivityInfo(comp, flags, userId);
if (ai != null) {
final ResolveInfo ri = new ResolveInfo();
ri.activityInfo = ai;
list.add(ri);
}
return list;
}
synchronized (mPackages) {
final String pkgName = intent.getPackage();
if (pkgName == null) {
return mActivities.queryIntent(intent, resolvedType, flags, userId);
}
final PackageParser.Package pkg = mPackages.get(pkgName);
if (pkg != null) {
// C
return mActivities.queryIntentForPackage(intent, resolvedType, flags,
pkg.activities, userId);
}
return new ArrayList<ResolveInfo>();
}
}对于上面的代码，可以看出:如果Intent 指明了Componet，那么直接通过Componet就可以找到ActivityInfo
如果指定了packagename,那么可以通过packagename找到Package,然后通过Package包含的Activities中进行匹配
如果都不满足，那么需要全系统进行匹配。
写到这里，我们有必要对上一篇文章中的一些重要数据结构进行回忆。
回忆1：PackageManagerService中有两个scanPackageLI，第一个scanPackageLI的第一个参数是File,它的工作就是将指定的文件(apk)的AndroidManifest.xml文件解析成PackageParser.Package对象。我们看看这个对象有哪些字段吧
图1-2
这里我仅仅列出了比较重要的字段，相信大家看了就会明白，Package里面存储了一个apk中的所有信息，其中包括所有的Activity,所有的Service等等。并且在PMS中有一个HashMap保存了所有的Pacakge,其中key就是包名
回忆2：在第二个scanPackageLI中，会将指定Package中的一些信息进行公有化，例如会将activities中的所有Activity加入ActivityIntentResolver类型的变量mActivities变量中。注意这里说的Activity和我们平时用的Activity不是一个类型，它的继承结构如下：
图1-3
回忆3：在scanPackageLI中，通过调用ActivityIntentResolver的addActivity方法，将指定的PackageParser.Activity保存起来，我们看看addActivity做了什么。
/**
* @param a
* 要被保存的Activity
* @param type
* "activity" or "recevier"
*/
public final void addActivity(PackageParser.Activity a, String type) {
final boolean systemApp = isSystemApp(a.info.applicationInfo);
//保存到一个HashMap中
mActivities.put(a.getComponentName(), a);
final int NI = a.intents.size();
//遍历Activity中所有的IntentFilter,然后调用addFilter方法进行保存
for (int j=0; j<NI; j++) {
PackageParser.ActivityIntentInfo intent = a.intents.get(j);
if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {
intent.setPriority(0);
Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "
+ a.className + " with priority > 0, forcing to 0");
}
if (DEBUG_SHOW_INFO) {
Log.v(TAG, " IntentFilter:");
intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
}
if (!intent.debugCheck()) {
Log.w(TAG, "==> For Activity " + a.info.name);
}
addFilter(intent);
}
}
逻辑比较简单，直接进入addFilter函数，看看做了些什么
public void addFilter(F f) {
mFilters.add(f);
int numS = register_intent_filter(f, f.schemesIterator(),
mSchemeToFilter, " Scheme: ");
int numT = register_mime_types(f, " Type: ");
if (numS == 0 && numT == 0) {
register_intent_filter(f, f.actionsIterator(),
mActionToFilter, " Action: ");
}
if (numT != 0) {
register_intent_filter(f, f.actionsIterator(),
mTypedActionToFilter, " TypedAction: ");
}
}其中mFilters是一个HashSet类型变量，这个方法首先将ActivityIntentInfo类型变量保存到mFilters中，接着调用了register_intent_filter方法
private final int register_intent_filter(F filter, Iterator<String> i,
HashMap<String, ArrayList<F>> dest, String prefix) {
if (i == null) {
return 0;
}
int num = 0;
while (i.hasNext()) {
String name = i.next();
num++;
if (localLOGV) Slog.v(TAG, prefix + name);
ArrayList<F> array = dest.get(name);
if (array == null) {
//Slog.v(TAG, "Creating new array for " + name);
array = new ArrayList<F>();
dest.put(name, array);
}
array.add(filter);
}
return num;
}在看代码之前，需要熟悉这里的数据结构，filter就相当于一个IntentFilter,i 是一个迭代器，通过它我们可以遍历filter所有的scheme,dest就是一个HashMap，key是filter的scheme,值就是一个ArrayList<F>，其实就是通过遍历一个IntentFilter的所有scheme，根据这个scheme找到对应的ArrayList<F>,然后将这个Filter放入ArrayList<F>,然后返回scheme的个数。
现在回到addFilter方法，接着会带调用register_mime_types方法，同样，看看这个方法做了什么
private final int register_mime_types(F filter, String prefix) {
final Iterator<String> i = filter.typesIterator();
if (i == null) {
return 0;
}
int num = 0;
while (i.hasNext()) {
String name = i.next();
num++;
if (localLOGV) Slog.v(TAG, prefix + name);
String baseName = name;
final int slashpos = name.indexOf(‘/‘);
if (slashpos > 0) {
baseName = name.substring(0, slashpos).intern();
} else {
name = name + "/*";
}
ArrayList<F> array = mTypeToFilter.get(name);
if (array == null) {
//Slog.v(TAG, "Creating new array for " + name);
array = new ArrayList<F>();
mTypeToFilter.put(name, array);
}
array.add(filter);
if (slashpos > 0) {
array = mBaseTypeToFilter.get(baseName);
if (array == null) {
//Slog.v(TAG, "Creating new array for " + name);
array = new ArrayList<F>();
mBaseTypeToFilter.put(baseName, array);
}
array.add(filter);
} else {
array = mWildTypeToFilter.get(baseName);
if (array == null) {
//Slog.v(TAG, "Creating new array for " + name);
array = new ArrayList<F>();
mWildTypeToFilter.put(baseName, array);
}
array.add(filter);
}
}
return num;
}这个方法的功能和register_intent_filter方法功能是一样的，只不过register_intent_filter是处理scheme的，这里是处理type的，type的逻辑比scheme复杂。scheme只用了一个mSchemeToFilter存储，而type用了三个，他们分别是：
mWildTypeToFilter：用于保存设置了Data类型“image/*”的IntentFilter，但是设置“image/jpeg”的不算在内
mTypeToFilter：包含了mWildTypeToFilter以及指明了Data类型为确定参数的IntentFilter信息，如“image/jpeg”和“image/*”类型
mBaseTypeToFilter：保存MIME中Base类型的IntentFilter,但是不包含Sub type为"*"的IntentFilter
其实上面回忆的3点都是前面一篇文章的内容，下面就开始研究一下queryIntentActivities的逻辑吧。
public List<ResolveInfo> queryIntentActivities(Intent intent,
String resolvedType, int flags, int userId) {
if (!sUserManager.exists(userId)) return null;
ComponentName comp = intent.getComponent();
if (comp == null) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
comp = intent.getComponent();
}
}
if (comp != null) {
final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
final ActivityInfo ai = getActivityInfo(comp, flags, userId);
if (ai != null) {
final ResolveInfo ri = new ResolveInfo();
ri.activityInfo = ai;
list.add(ri);
}
return list;
}
// reader
synchronized (mPackages) {
final String pkgName = intent.getPackage();
if (pkgName == null) {
return mActivities.queryIntent(intent, resolvedType, flags, userId);
}
final PackageParser.Package pkg = mPackages.get(pkgName);
if (pkg != null) {
return mActivities.queryIntentForPackage(intent, resolvedType, flags,
pkg.activities, userId);
}
return new ArrayList<ResolveInfo>();
}
}
这部分代码逻辑其实也不算复杂，通过Intent拿到ComponetName,如果ComponetName不为null(说明使用的是显示调用)，那么通过调用getActivityInfo方法拿到ActivityInfo。getActivityInfo其实就是到mActivities里面根据ComponetName拿到PackageParser.Activity对象，并通过调用PackageParser.generateActivityInfo方法将PackageParser.Activity对象变为ActivityInfo对象。如果ComponetName为null(隐式调用),那么就要分为两种情况：
第一种情况：通过intent拿到包名为Null,那么调用ActivityIntentResolver的queryIntent方法
public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
boolean defaultOnly, int userId) {
if (!sUserManager.exists(userId)) return null;
mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
return super.queryIntent(intent, resolvedType, defaultOnly, userId);
}代码很少，调用了IntentResolver的queryIntent，直接看queryIntent的源码吧
public List<R> queryIntent(Intent intent, String resolvedType, boolean defaultOnly,
int userId) {
String scheme = intent.getScheme();
ArrayList<R> finalList = new ArrayList<R>();
final boolean debug = localLOGV ||
((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
if (debug) Slog.v(
TAG, "Resolving type " + resolvedType + " scheme " + scheme
+ " of intent " + intent);
ArrayList<F> firstTypeCut = null;
ArrayList<F> secondTypeCut = null;
ArrayList<F> thirdTypeCut = null;
ArrayList<F> schemeCut = null;
// If the intent includes a MIME type, then we want to collect all of
// the filters that match that MIME type.
if (resolvedType != null) {
int slashpos = resolvedType.indexOf(‘/‘);
if (slashpos > 0) {
final String baseType = resolvedType.substring(0, slashpos);
if (!baseType.equals("*")) {
if (resolvedType.length() != slashpos+2
|| resolvedType.charAt(slashpos+1) != ‘*‘) {
// Not a wild card, so we can just look for all filters that
// completely match or wildcards whose base type matches.
firstTypeCut = mTypeToFilter.get(resolvedType);
if (debug) Slog.v(TAG, "First type cut: " + firstTypeCut);
secondTypeCut = mWildTypeToFilter.get(baseType);
if (debug) Slog.v(TAG, "Second type cut: " + secondTypeCut);
} else {
// We can match anything with our base type.
firstTypeCut = mBaseTypeToFilter.get(baseType);
if (debug) Slog.v(TAG, "First type cut: " + firstTypeCut);
secondTypeCut = mWildTypeToFilter.get(baseType);
if (debug) Slog.v(TAG, "Second type cut: " + secondTypeCut);
}
// Any */* types always apply, but we only need to do this
// if the intent type was not already */*.
thirdTypeCut = mWildTypeToFilter.get("*");
if (debug) Slog.v(TAG, "Third type cut: " + thirdTypeCut);
} else if (intent.getAction() != null) {
// The intent specified any type ({@literal *}/*). This
// can be a whole heck of a lot of things, so as a first
// cut let‘s use the action instead.
firstTypeCut = mTypedActionToFilter.get(intent.getAction());
if (debug) Slog.v(TAG, "Typed Action list: " + firstTypeCut);
}
}
}
// If the intent includes a data URI, then we want to collect all of
// the filters that match its scheme (we will further refine matches
// on the authority and path by directly matching each resulting filter).
if (scheme != null) {
schemeCut = mSchemeToFilter.get(scheme);
if (debug) Slog.v(TAG, "Scheme list: " + schemeCut);
}
// If the intent does not specify any data -- either a MIME type or
// a URI -- then we will only be looking for matches against empty
// data.
if (resolvedType == null && scheme == null && intent.getAction() != null) {
firstTypeCut = mActionToFilter.get(intent.getAction());
if (debug) Slog.v(TAG, "Action list: " + firstTypeCut);
}
FastImmutableArraySet<String> categories = getFastIntentCategories(intent);
if (firstTypeCut != null) {
buildResolveList(intent, categories, debug, defaultOnly,
resolvedType, scheme, firstTypeCut, finalList, userId);
}
if (secondTypeCut != null) {
buildResolveList(intent, categories, debug, defaultOnly,
resolvedType, scheme, secondTypeCut, finalList, userId);
}
if (thirdTypeCut != null) {
buildResolveList(intent, categories, debug, defaultOnly,
resolvedType, scheme, thirdTypeCut, finalList, userId);
}
if (schemeCut != null) {
buildResolveList(intent, categories, debug, defaultOnly,
resolvedType, scheme, schemeCut, finalList, userId);
}
sortResults(finalList);
if (debug) {
Slog.v(TAG, "Final result list:");
for (R r : finalList) {
Slog.v(TAG, " " + r);
}
}
return finalList;
}这个函数看起来很复杂，但是逻辑很简单，我在这里简单的描述一下。
首先如果给定的Intent包含MIME，就到上面(mTypeToFilter,mWildTypeToFilter,mBaseTypeToFilter)里面匹配符合条件的IntentFilter,将结果分别保存到firstTypeCut，secondTypeCut，thirdTypeCut中，然后根据scheme进行匹配，将结果保存到schemeCut，最后调用buildResolveList方法，将action,scheme,categories等因素随后匹配，将结果保存到finalList中去，最后对finalList进行排序。这种情况分析完了。
第二种情况：如果intent中的包名不为Null，根据包名拿到PackageParser.Package对象，调用ActivityIntentResolver的queryIntentForPackage方法即可，此方法中遍历PackageParsr.Package中的mactivities对象，将每个PackageParser.Activity中的所有IntentFilter加入listCut(一个ArrayList)中，然后调用IntentResolve的queryIntentFromList方法，在queryIntentFromList方法中，根据给定的Intent的action,categories,scheme,type等信息匹配listCut中的IntentFilter对象。
好了关于Intent的匹配过程就写到这里。
深入分析Intent匹配查询
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。