_dowork
_dowork

Android6.0 AMS启动Activity(六) AMS与PKMS关系（通过Intent获取ActivityInfo）

之前几篇博客分析AMS中启动Activity的时候，我们把主要流程理的差不多了。今天主要看下AMS中通过PKMS来获取ActivityInfo。


一、AMS通过PKMS获取ActivityInfo

之前我们知道startActivity流程，先是在AMS中调用startActivity然后调用startActivityMayWait函数，在这个函数中调用了resolveActivity来解析ActivityInfo信息。后面这个函数继续往后会调用startActivityLocked函数，在这个函数中会新建一个ActivityRecord对象，这个对象的processName和info.applicartionInfo.uid这两个值在后续进程启动的时候起到很关键的作用，用来判断进程是否启动，这个在之前的博客中已经分析过了。而processName是利用ActivityInfo的processName。而info.applicationInfo.uid也是ActivityInfo中的ApplicationInfo的值。

[cpp] view plain copy
  1. final int startActivityMayWait(IApplicationThread caller, int callingUid,  
  2.         String callingPackage, Intent intent, String resolvedType,  
  3.         IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,  
  4.         IBinder resultTo, String resultWho, int requestCode, int startFlags,  
  5.         ProfilerInfo profilerInfo, WaitResult outResult, Configuration config,  
  6.         Bundle options, boolean ignoreTargetSecurity, int userId,  
  7.         IActivityContainer iContainer, TaskRecord inTask) {  
  8.     // Refuse possible leaked file descriptors  
  9.     if (intent != null && intent.hasFileDescriptors()) {  
  10.         throw new IllegalArgumentException("File descriptors passed in Intent");  
  11.     }  
  12.     boolean componentSpecified = intent.getComponent() != null;  
  13.   
  14.     // Don't modify the client's object!  
  15.     intent = new Intent(intent);  
  16.   
  17.     // Collect information about the target of the Intent.  
  18.     ActivityInfo aInfo =  
  19.             resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);  

那我们下面来看看这个resolveActivity函数，这个函数最终还是通过PKMS的resolveIntent函数来获取ResolveInfo，而ActivityInfo是其中的一个变量。

[cpp] view plain copy
  1. ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags,  
  2.         ProfilerInfo profilerInfo, int userId) {  
  3.     // Collect information about the target of the Intent.  
  4.     ActivityInfo aInfo;  
  5.     try {  
  6.         ResolveInfo rInfo =  
  7.             AppGlobals.getPackageManager().resolveIntent(  
  8.                     intent, resolvedType,  
  9.                     PackageManager.MATCH_DEFAULT_ONLY  
  10.                                 | ActivityManagerService.STOCK_PM_FLAGS, userId);  
  11.         aInfo = rInfo != null ? rInfo.activityInfo : null;  
  12.     } catch (RemoteException e) {  
  13.         aInfo = null;  
  14.     }  
  15.   
  16.     if (aInfo != null) {  
  17.         // Store the found target back into the intent, because now that  
  18.         // we have it we never want to do this again.  For example, if the  
  19.         // user navigates back to this point in the history, we should  
  20.         // always restart the exact same activity.  
  21.         intent.setComponent(new ComponentName(  
  22.                 aInfo.applicationInfo.packageName, aInfo.name));  
  23.   
  24.         // Don't debug things in the system process  
  25.         if ((startFlags&ActivityManager.START_FLAG_DEBUG) != 0) {  
  26.             if (!aInfo.processName.equals("system")) {  
  27.                 mService.setDebugApp(aInfo.processName, true, false);  
  28.             }  
  29.         }  
  30.   
  31.         if ((startFlags&ActivityManager.START_FLAG_OPENGL_TRACES) != 0) {  
  32.             if (!aInfo.processName.equals("system")) {  
  33.                 mService.setOpenGlTraceApp(aInfo.applicationInfo, aInfo.processName);  
  34.             }  
  35.         }  
  36.   
  37.         if (profilerInfo != null) {  
  38.             if (!aInfo.processName.equals("system")) {  
  39.                 mService.setProfileApp(aInfo.applicationInfo, aInfo.processName, profilerInfo);  
  40.             }  
  41.         }  
  42.     }  
  43.     return aInfo;  
  44. }  


二、PKMS获取ActivityInfo

我们来看下PKMS的resolveIntent函数，先看下是否有权限，然后调用queryIntentActivities来获取满足条件的ResolveInfo，然后调用chooseBestActivity挑选最合适的。

[cpp] view plain copy
  1. @Override  
  2. public ResolveInfo resolveIntent(Intent intent, String resolvedType,  
  3.         int flags, int userId) {  
  4.     if (!sUserManager.exists(userId)) return null;  
  5.     enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "resolve intent");  
  6.     List query = queryIntentActivities(intent, resolvedType, flags, userId);  
  7.     return chooseBestActivity(intent, resolvedType, flags, query, userId);  
  8. }  

所以这里我们主要看下queryIntentActivities函数，先会检查权限。然后获取ComponentName，如果不为空，那么Intent是指定了模块，只有一个匹配项。如果没有指定模块，还要区分是否指定了包名。

[cpp] view plain copy
  1. public List queryIntentActivities(Intent intent,  
  2.         String resolvedType, int flags, int userId) {  
  3.     if (!sUserManager.exists(userId)) return Collections.emptyList();  
  4.     enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "query intent activities");  
  5.     ComponentName comp = intent.getComponent();  
  6.     if (comp == null) {  
  7.         if (intent.getSelector() != null) {  
  8.             intent = intent.getSelector();  
  9.             comp = intent.getComponent();  
  10.         }  
  11.     }  
  12.   
  13.     if (comp != null) {//如果Intent中指定了模块，只会有一个匹配项  
  14.         final List list = new ArrayList(1);  
  15.         final ActivityInfo ai = getActivityInfo(comp, flags, userId);  
  16.         if (ai != null) {  
  17.             final ResolveInfo ri = new ResolveInfo();  
  18.             ri.activityInfo = ai;  
  19.             list.add(ri);  
  20.         }  
  21.         return list;  
  22.     }  
  23.   
  24.     // reader  
  25.     synchronized (mPackages) {  
  26.         final String pkgName = intent.getPackage();  
  27.         if (pkgName == null) {//intent没有指定包名，在系统所有包中查找  
  28.             List matchingFilters =  
  29.                     getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);//获取所有匹配的intent filter  
  30.             // Check for results that need to skip the current profile.  
  31.             ResolveInfo xpResolveInfo  = querySkipCurrentProfileIntents(matchingFilters, intent,  
  32.                     resolvedType, flags, userId);  
  33.             if (xpResolveInfo != null && isUserEnabled(xpResolveInfo.targetUserId)) {  
  34.                 List result = new ArrayList(1);  
  35.                 result.add(xpResolveInfo);  
  36.                 return filterIfNotPrimaryUser(result, userId);  
  37.             }  
  38.   
  39.             // Check for results in the current profile.  
  40.             List result = mActivities.queryIntent(  
  41.                     intent, resolvedType, flags, userId);  
  42.   
  43.             // Check for cross profile results.  
  44.             xpResolveInfo = queryCrossProfileIntents(  
  45.                     matchingFilters, intent, resolvedType, flags, userId);  
  46.             if (xpResolveInfo != null && isUserEnabled(xpResolveInfo.targetUserId)) {  
  47.                 result.add(xpResolveInfo);  
  48.                 Collections.sort(result, mResolvePrioritySorter);  
  49.             }  
  50.             result = filterIfNotPrimaryUser(result, userId);  
  51.             if (hasWebURI(intent)) {  
  52.                 CrossProfileDomainInfo xpDomainInfo = null;  
  53.                 final UserInfo parent = getProfileParent(userId);  
  54.                 if (parent != null) {  
  55.                     xpDomainInfo = getCrossProfileDomainPreferredLpr(intent, resolvedType,  
  56.                             flags, userId, parent.id);  
  57.                 }  
  58.                 if (xpDomainInfo != null) {  
  59.                     if (xpResolveInfo != null) {  
  60.                         // If we didn't remove it, the cross-profile ResolveInfo would be twice  
  61.                         // in the result.  
  62.                         result.remove(xpResolveInfo);  
  63.                     }  
  64.                     if (result.size() == 0) {  
  65.                         result.add(xpDomainInfo.resolveInfo);  
  66.                         return result;  
  67.                     }  
  68.                 } else if (result.size() <= 1) {  
  69.                     return result;  
  70.                 }  
  71.                 result = filterCandidatesWithDomainPreferredActivitiesLPr(intent, flags, result,  
  72.                         xpDomainInfo, userId);  
  73.                 Collections.sort(result, mResolvePrioritySorter);  
  74.             }  
  75.             return result;  
  76.         }  
  77.         final PackageParser.Package pkg = mPackages.get(pkgName);  
  78.         if (pkg != null) {//如果Intent中有包名，就在指定包中查找  
  79.             return filterIfNotPrimaryUser(  
  80.                     mActivities.queryIntentForPackage(  
  81.                             intent, resolvedType, flags, pkg.activities, userId),  
  82.                     userId);  
  83.         }  
  84.         return new ArrayList();  
  85.     }  
  86. }  

这个函数会根据Intent中的信息来分别处理。如果Intent有包名和Activity信息（指定了模块）直接返回ActivityInfo，这是最快的方式。如果只有包名，调用queryIntentForPackage在指定的安装包中查找Activity。如果包名也没有，只能调用queryIntent来搜索所有安装包了，这是最慢的一种查询方式了。

我们这里就看最直接的方式，我们看上面函数是直接调用了getActivityInfo方法来获取ActivityInfo的。直接通过mActivities.mActivities中的component来获取Activity，然后通过PackageParser.generateActivityInfo来产生一个ActivityInfo

[cpp] view plain copy
  1. public ActivityInfo getActivityInfo(ComponentName component, int flags, int userId) {  
  2.     if (!sUserManager.exists(userId)) return null;  
  3.     enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get activity info");//检查权限  
  4.     synchronized (mPackages) {  
  5.         PackageParser.Activity a = mActivities.mActivities.get(component);//获取到Activity  
  6.   
  7.         if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);  
  8.         if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {  
  9.             PackageSetting ps = mSettings.mPackages.get(component.getPackageName());  
  10.             if (ps == null) return null;  
  11.             return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),//得到ActivityInfo  
  12.                     userId);  
  13.         }  
  14.         if (mResolveComponentName.equals(component)) {  
  15.             return PackageParser.generateActivityInfo(mResolveActivity, flags,  
  16.                     new PackageUserState(), userId);  
  17.         }  
  18.     }  
  19.     return null;  
  20. }  

我们来看下这个generateActivityInfo函数，其实就是利用Activity的成员变量info来重新构造了一个ActivityInfo，然后再赋值ApplicationInfo等。

[cpp] view plain copy
  1. public static final ActivityInfo generateActivityInfo(Activity a, int flags,  
  2.         PackageUserState state, int userId) {  
  3.     if (a == null) return null;  
  4.     if (!checkUseInstalledOrHidden(flags, state)) {  
  5.         return null;  
  6.     }  
  7.     if (!copyNeeded(flags, a.owner, state, a.metaData, userId)) {  
  8.         return a.info;  
  9.     }  
  10.     // Make shallow copies so we can store the metadata safely  
  11.     ActivityInfo ai = new ActivityInfo(a.info);  
  12.     ai.metaData = a.metaData;  
  13.     ai.applicationInfo = generateApplicationInfo(a.owner, flags, state, userId);  
  14.     return ai;  
  15. }  

这里最关键的就是mActivities成员变量了，它是ActivityIntentResolver对象

[cpp] view plain copy
  1. final ActivityIntentResolver mActivities =  
  2.         new ActivityIntentResolver();  

还是就是ActivityIntentResolver的成员变量mActivities是一个map key就是ComponentName，通过ComponentName来找到Activity的。

[cpp] view plain copy
  1. // Keys are String (activity class name), values are Activity.  
  2. private final ArrayMap mActivities  
  3.         = new ArrayMap();  



三、mActivities变量中的Activity添加

3.1 开机扫描和安装应用大致流程

之前的博客讲PKMS的时候分析过无论是开机扫描各个目录的apk文件，还是安装新的apk最后都会调用scanPackageDirtyLI方法。

我们来简单回顾下，开机扫描各个目录的时候是调用scanDirLI函数，然后调用scanPackageLI函数这个函数第一个参数是File，这个函数会新建一个PackageParser对象，来解析文件。最后也会调用另一个scanPackageLI方法这个参数是Packageparser.Package类。而在这个scanPackageLI方法中最后调用了scanPackageDirtyLI方法。

在安装一个新应用的时候先copy apk文件到指定目录，后面会调用installPackageLI，这个函数也会创建一个PackageParser对象来解析apk文件，后面会调用installNewPackageLI继续处理，最后会发送广播通知其他应用，比如Launcher增加图标等。在installNewPackageLI函数中也会调用scanPackageLI函数，是参数是Packageparser.Package类。而最后就会调用scanPackageDirtyLI方法。

所以其实无论开机扫描还是安装应用其实流程差不多。


3.2 scanPackageDirtyLI方法处理mActivities

我们再来看下scanPackageDirtyLI方法中的一段代码，首先从PackageParser.Package中遍历其Activity，然后制定其info.processName最后把Activity放入到mActivities中。

[cpp] view plain copy
  1. N = pkg.activities.size();  
  2. r = null;  
  3. for (i=0; i
  4.     PackageParser.Activity a = pkg.activities.get(i);  
  5.     a.info.processName = fixProcessName(pkg.applicationInfo.processName,  
  6.             a.info.processName, pkg.applicationInfo.uid);  
  7.     mActivities.addActivity(a, "activity");  
  8.     if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {  
  9.         if (r == null) {  
  10.             r = new StringBuilder(256);  
  11.         } else {  
  12.             r.append(' ');  
  13.         }  
  14.         r.append(a.info.name);  
  15.     }  
  16. }  

再来看fixProcessName函数，结合上面的参数当a.info.processName有的话processName就是这个值，没有的话才是pkg.applicationInfo.processName。

[cpp] view plain copy
  1. private static String fixProcessName(String defProcessName,  
  2.         String processName, int uid) {  
  3.     if (processName == null) {  
  4.         return defProcessName;  
  5.     }  
  6.     return processName;  
  7. }  

下面我们再来看ActivityIntentResolver类的addActivity函数，其实主要就是放入了mActivities变量中，其key就是ComponentName。

[cpp] view plain copy
  1. public final void addActivity(PackageParser.Activity a, String type) {  
  2.     final boolean systemApp = a.info.applicationInfo.isSystemApp();  
  3.     mActivities.put(a.getComponentName(), a);  
  4.     final int NI = a.intents.size();  
  5.     for (int j=0; j
  6.         PackageParser.ActivityIntentInfo intent = a.intents.get(j);  
  7.         if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {  
  8.             intent.setPriority(0);  
  9.             Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "  
  10.                     + a.className + " with priority > 0, forcing to 0");  
  11.         }  
  12.         if (DEBUG_SHOW_INFO) {  
  13.             Log.v(TAG, "    IntentFilter:");  
  14.             intent.dump(new LogPrinter(Log.VERBOSE, TAG), "      ");  
  15.         }  
  16.         if (!intent.debugCheck()) {  
  17.             Log.w(TAG, "==> For Activity " + a.info.name);  
  18.         }  
  19.         addFilter(intent);  
  20.     }  
  21. }  

我们回过头来看下，其实ActivityIntentResolver中mActivities中的值也是从PackageParser.Package中遍历其Activity，稍微修改下在add到mActivities中的。所以还是主要看PackageParser.Package中的Activity的由来。


四、PackageParser.Package的activities的ComponentName & info.processName

而PackageParser.Package的值无论是开机扫描还是新安装应用都是新建一个PackageParser，然后解析文件得到的。

只是开机扫描是在scanPackageLI函数中调用：

[cpp] view plain copy
  1. private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanFlags,  
  2.         long currentTime, UserHandle user) throws PackageManagerException {  
  3.     if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);  
  4.     parseFlags |= mDefParseFlags;  
  5.     PackageParser pp = new PackageParser();  
  6.     pp.setSeparateProcesses(mSeparateProcesses);  
  7.     pp.setOnlyCoreApps(mOnlyCore);  
  8.     pp.setDisplayMetrics(mMetrics);  
  9.   
  10.     if ((scanFlags & SCAN_TRUSTED_OVERLAY) != 0) {  
  11.         parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;  
  12.     }  
  13.   
  14.     final PackageParser.Package pkg;  
  15.     try {  
  16.         pkg = pp.parsePackage(scanFile, parseFlags);  
  17.     } catch (PackageParserException e) {  
  18.         throw PackageManagerException.from(e);  
  19.     }  
  20. ..  

而安装应用是在installPackageLI函数中调用：

[cpp] view plain copy
  1. private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {  
  2.     final int installFlags = args.installFlags;  
  3.     final String installerPackageName = args.installerPackageName;  
  4.     final String volumeUuid = args.volumeUuid;  
  5.     final File tmpPackageFile = new File(args.getCodePath());  
  6.     final boolean forwardLocked = ((installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0);  
  7.     final boolean onExternal = (((installFlags & PackageManager.INSTALL_EXTERNAL) != 0)  
  8.             || (args.volumeUuid != null));  
  9.     boolean replace = false;  
  10.     int scanFlags = SCAN_NEW_INSTALL | SCAN_UPDATE_SIGNATURE;  
  11.     if (args.move != null) {  
  12.         // moving a complete application; perfom an initial scan on the new install location  
  13.         scanFlags |= SCAN_INITIAL;  
  14.     }  
  15.     // Result object to be returned  
  16.     res.returnCode = PackageManager.INSTALL_SUCCEEDED;  
  17.   
  18.     if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);  
  19.     // Retrieve PackageSettings and parse package  
  20.     final int parseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY  
  21.             | (forwardLocked ? PackageParser.PARSE_FORWARD_LOCK : 0)  
  22.             | (onExternal ? PackageParser.PARSE_EXTERNAL_STORAGE : 0);  
  23.     PackageParser pp = new PackageParser();  
  24.     pp.setSeparateProcesses(mSeparateProcesses);  
  25.     pp.setDisplayMetrics(mMetrics);  
  26.   
  27.     final PackageParser.Package pkg;  
  28.     try {  
  29.         pkg = pp.parsePackage(tmpPackageFile, parseFlags);  
  30.     } catch (PackageParserException e) {  
  31.         res.setError("Failed parse during installPackageLI", e);  
  32.         return;  
  33.     }  
  34. ..  

我们来看PackageParser的parsePackage函数，这里是否是目录的话调用的函数不一样。

[cpp] view plain copy
  1. public Package parsePackage(File packageFile, int flags) throws PackageParserException {  
  2.     if (packageFile.isDirectory()) {  
  3.         return parseClusterPackage(packageFile, flags);  
  4.     } else {  
  5.         return parseMonolithicPackage(packageFile, flags);  
  6.     }  
  7. }  

我们先来看下如果是目录的话调用parseClusterPackage函数，而在这个函数先调用parseBaseApk，然后遍历所有的split，调用函数parseSplitApk函数。

[cpp] view plain copy
  1. private Package parseClusterPackage(File packageDir, int flags) throws PackageParserException {  
  2.     final PackageLite lite = parseClusterPackageLite(packageDir, 0);  
  3.   
  4.     if (mOnlyCoreApps && !lite.coreApp) {  
  5.         throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,  
  6.                 "Not a coreApp: " + packageDir);  
  7.     }  
  8.   
  9.     final AssetManager assets = new AssetManager();  
  10.     try {  
  11.         // Load the base and all splits into the AssetManager  
  12.         // so that resources can be overriden when parsing the manifests.  
  13.         loadApkIntoAssetManager(assets, lite.baseCodePath, flags);  
  14.   
  15.         if (!ArrayUtils.isEmpty(lite.splitCodePaths)) {  
  16.             for (String path : lite.splitCodePaths) {  
  17.                 loadApkIntoAssetManager(assets, path, flags);  
  18.             }  
  19.         }  
  20.   
  21.         final File baseApk = new File(lite.baseCodePath);  
  22.         final Package pkg = parseBaseApk(baseApk, assets, flags);  
  23.         if (pkg == null) {  
  24.             throw new PackageParserException(INSTALL_PARSE_FAILED_NOT_APK,  
  25.                     "Failed to parse base APK: " + baseApk);  
  26.         }  
  27.   
  28.         if (!ArrayUtils.isEmpty(lite.splitNames)) {  
  29.             final int num = lite.splitNames.length;  
  30.             pkg.splitNames = lite.splitNames;  
  31.             pkg.splitCodePaths = lite.splitCodePaths;  
  32.             pkg.splitRevisionCodes = lite.splitRevisionCodes;  
  33.             pkg.splitFlags = new int[num];  
  34.             pkg.splitPrivateFlags = new int[num];  
  35.   
  36.             for (int i = 0; i < num; i++) {  
  37.                 parseSplitApk(pkg, i, assets, flags);  
  38.             }  
  39.         }  
  40.   
  41.         pkg.codePath = packageDir.getAbsolutePath();  
  42.         return pkg;  
  43.     } finally {  
  44.         IoUtils.closeQuietly(assets);  
  45.     }  
  46. }  

而我们再看下parseMonolithicPackage函数，因为不是目录，所以只有一个apk，直接调用了parseBaseApk。

[cpp] view plain copy
  1. public Package parseMonolithicPackage(File apkFile, int flags) throws PackageParserException {  
  2.     if (mOnlyCoreApps) {  
  3.         final PackageLite lite = parseMonolithicPackageLite(apkFile, flags);  
  4.         if (!lite.coreApp) {  
  5.             throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,  
  6.                     "Not a coreApp: " + apkFile);  
  7.         }  
  8.     }  
  9.   
  10.     final AssetManager assets = new AssetManager();  
  11.     try {  
  12.         final Package pkg = parseBaseApk(apkFile, assets, flags);  
  13.         pkg.codePath = apkFile.getAbsolutePath();  
  14.         return pkg;  
  15.     } finally {  
  16.         IoUtils.closeQuietly(assets);  
  17.     }  
  18. }  

那我们来看下这个parseBaseApk函数，在这个函数中调用了另一个parseBaseApk函数，在这个函数新建了一个Package对象。然后遍历xml中各个节点，这里我们只关心application。在这个节点解析的时候直接调用了parseBaseApplication函数。

[cpp] view plain copy
  1. private Package parseBaseApk(Resources res, XmlResourceParser parser, int flags,  
  2.         String[] outError) throws XmlPullParserException, IOException {  
  3.     ......  
  4.     final Package pkg = new Package(pkgName);  
  5.     boolean foundApp = false;  
  6.   
  7.     TypedArray sa = res.obtainAttributes(attrs,  
  8.             com.android.internal.R.styleable.AndroidManifest);  
  9.     pkg.mVersionCode = pkg.applicationInfo.versionCode = sa.getInteger(  
  10.             com.android.internal.R.styleable.AndroidManifest_versionCode, 0);  
  11.     pkg.baseRevisionCode = sa.getInteger(  
  12.             com.android.internal.R.styleable.AndroidManifest_revisionCode, 0);  
  13.     pkg.mVersionName = sa.getNonConfigurationString(  
  14.             com.android.internal.R.styleable.AndroidManifest_versionName, 0);  
  15.     if (pkg.mVersionName != null) {  
  16.         pkg.mVersionName = pkg.mVersionName.intern();  
  17.     }  
  18.     ......  
  19.       
  20.     int outerDepth = parser.getDepth();  
  21.     while ((type = parser.next()) != XmlPullParser.END_DOCUMENT  
  22.             && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {  
  23.         if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {  
  24.             continue;  
  25.         }  
  26.   
  27.         String tagName = parser.getName();  
  28.         if (tagName.equals("application")) {  
  29.             if (foundApp) {  
  30.                 if (RIGID_PARSER) {  
  31.                     outError[0] = " has more than one ";  
  32.                     mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;  
  33.                     return null;  
  34.                 } else {  
  35.                     Slog.w(TAG, " has more than one ");  
  36.                     XmlUtils.skipCurrentTag(parser);  
  37.                     continue;  
  38.                 }  
  39.             }  
  40.   
  41.             foundApp = true;  
  42.             if (!parseBaseApplication(pkg, res, parser, attrs, flags, outError)) {  
  43.                 return null;  
  44.             }  
  45.         }   

我们再来看下parseBaseApplication函数，先获取了ApplicationInfo后面会修改器processName，再后面就开始就是xml中的application下的各个节点了。我们主要看下关于Activities的。是调用了parseActivity，然后保存在activities变量中。

[cpp] view plain copy
  1. private boolean parseBaseApplication(Package owner, Resources res,  
  2.         XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)  
  3.     throws XmlPullParserException, IOException {  
  4.     final ApplicationInfo ai = owner.applicationInfo;  
  5.     final String pkgName = owner.applicationInfo.packageName;  
  6.     ......  
  7.       
  8.                 ai.processName = buildProcessName(ai.packageName, null, pname,  
  9.                 flags, mSeparateProcesses, outError);  
  10.     ......  
  11.     while ((type = parser.next()) != XmlPullParser.END_DOCUMENT  
  12.             && (type != XmlPullParser.END_TAG || parser.getDepth() > innerDepth)) {  
  13.         if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {  
  14.             continue;  
  15.         }  
  16.   
  17.         String tagName = parser.getName();  
  18.         if (tagName.equals("activity")) {  
  19.             Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false,  
  20.                     owner.baseHardwareAccelerated);  
  21.             if (a == null) {  
  22.                 mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;  
  23.                 return false;  
  24.             }  
  25.   
  26.             owner.activities.add(a);  
  27.   
  28.         }  

parseActivity新建了一个Activity对象，然后解析各种数据保存在info等变量中。但是仔细看没有我们想要的东西。

1.没有看到Activity的info.processName

2.没有看到Activity的ComponentName

[cpp] view plain copy
  1. private Activity parseActivity(Package owner, Resources res,  
  2.         XmlPullParser parser, AttributeSet attrs, int flags, String[] outError,  
  3.         boolean receiver, boolean hardwareAccelerated)  
  4.         throws XmlPullParserException, IOException {  
  5.     TypedArray sa = res.obtainAttributes(attrs, R.styleable.AndroidManifestActivity);  
  6.   
  7.     if (mParseActivityArgs == null) {  
  8.         mParseActivityArgs = new ParseComponentArgs(owner, outError,  
  9.                 R.styleable.AndroidManifestActivity_name,  
  10.                 R.styleable.AndroidManifestActivity_label,  
  11.                 R.styleable.AndroidManifestActivity_icon,  
  12.                 R.styleable.AndroidManifestActivity_logo,  
  13.                 R.styleable.AndroidManifestActivity_banner,  
  14.                 mSeparateProcesses,  
  15.                 R.styleable.AndroidManifestActivity_process,  
  16.                 R.styleable.AndroidManifestActivity_description,  
  17.                 R.styleable.AndroidManifestActivity_enabled);  
  18.     }  
  19.       
  20.     mParseActivityArgs.tag = receiver ? "" : "";  
  21.     mParseActivityArgs.sa = sa;  
  22.     mParseActivityArgs.flags = flags;  
  23.       
  24.     Activity a = new Activity(mParseActivityArgs, new ActivityInfo());  
我们先看下Activity的构造函数，其父类是public static class Component
[cpp] view plain copy
  1. public Activity(final ParseComponentArgs args, final ActivityInfo _info) {  
  2.     super(args, _info);  
  3.     info = _info;  
  4.     info.applicationInfo = args.owner.applicationInfo;  
  5. }  

我们看其父类的函数，也没有看到起关于ComponentName的设置，但是会对outInfo的processName进行设置，也就是Activity的info的processName。那这里解了我们第一个疑惑info的processName。

[cpp] view plain copy
  1. public Component(final ParseComponentArgs args, final ComponentInfo outInfo) {  
  2.     this(args, (PackageItemInfo)outInfo);  
  3.     if (args.outError[0] != null) {  
  4.         return;  
  5.     }  
  6.   
  7.     if (args.processRes != 0) {  
  8.         CharSequence pname;  
  9.         if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {  
  10.             pname = args.sa.getNonConfigurationString(args.processRes,  
  11.                     Configuration.NATIVE_CONFIG_VERSION);  
  12.         } else {  
  13.             // Some older apps have been seen to use a resource reference  
  14.             // here that on older builds was ignored (with a warning).  We  
  15.             // need to continue to do this for them so they don't break.  
  16.             pname = args.sa.getNonResourceString(args.processRes);  
  17.         }  
  18.         outInfo.processName = buildProcessName(owner.applicationInfo.packageName,  
  19.                 owner.applicationInfo.processName, pname,  
  20.                 args.flags, args.sepProcesses, args.outError);  
  21.     }  
  22.       
  23.     if (args.descriptionRes != 0) {  
  24.         outInfo.descriptionRes = args.sa.getResourceId(args.descriptionRes, 0);  
  25.     }  
  26.       
  27.     outInfo.enabled = args.sa.getBoolean(args.enabledRes, true);  
  28. }  

那么第二个ComponentName呢，我再来看上面这个函数第一句话是调用了另一个构造函数，在这里我们构造了className。当然这里获取className的方式有点复杂，和一些资源相关。

[cpp] view plain copy
  1. public Component(final ParsePackageItemArgs args, final PackageItemInfo outInfo) {  
  2.     owner = args.owner;  
  3.     intents = new ArrayList(0);  
  4.     String name = args.sa.getNonConfigurationString(args.nameRes, 0);  
  5.     if (name == null) {  
  6.         className = null;  
  7.         args.outError[0] = args.tag + " does not specify android:name";  
  8.         return;  
  9.     }  
  10.   
  11.     outInfo.name  
  12.         = buildClassName(owner.applicationInfo.packageName, name, args.outError);  
  13.     if (outInfo.name == null) {  
  14.         className = null;  
  15.         args.outError[0] = args.tag + " does not have valid android:name";  
  16.         return;  
  17.     }  
  18.   
  19.     className = outInfo.name;  

而我们再看下Activity的getComponentName函数，只要有className就会新建一个ComponentName对象。

[cpp] view plain copy
  1. public ComponentName getComponentName() {  
  2.     if (componentName != null) {  
  3.         return componentName;  
  4.     }  
  5.     if (className != null) {  
  6.         componentName = new ComponentName(owner.applicationInfo.packageName,  
  7.                 className);  
  8.     }  
  9.     return componentName;  
  10. }  

ComponentName的构造函数也就是保存两个变量。

[cpp] view plain copy
  1. public ComponentName(String pkg, String cls) {  
  2.     if (pkg == null) throw new NullPointerException("package name is null");  
  3.     if (cls == null) throw new NullPointerException("class name is null");  
  4.     mPackage = pkg;  
  5.     mClass = cls;  
  6. }  

那么这样ComponentName和processName的问题都解决了。


五、uid值由来

给AMS传递的ActivityInfo，还有一个重要的信息就是uid，是在ApplicationInfo中的。我们来看下在哪里赋值的。

在scanPackageDirtyLI函数中有一句

[cpp] view plain copy
  1. pkg.applicationInfo.uid = pkgSetting.appId;  

我们再看下Activity的构造函数，info.applicationInfo就是Package的applicationinfo。因此上面给uid赋值，就是ActivityInfo的applicationInfo的uid赋值。

[cpp] view plain copy
  1. public Activity(final ParseComponentArgs args, final ActivityInfo _info) {  
  2.     super(args, _info);  
  3.     info = _info;  
  4.     info.applicationInfo = args.owner.applicationInfo;  
  5. }  

那我们再看看pkgSetting.appId的由来，同样在scanPackageDirtyLI函数中有如下代码，创建一个pkgSetting。

[cpp] view plain copy
  1. pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,  
  2.         destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,  
  3.         pkg.applicationInfo.primaryCpuAbi,  
  4.         pkg.applicationInfo.secondaryCpuAbi,  
  5.         pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags,  
  6.         user, false);  

我们来看下这个函数，它调用了另一个getPackageLPw函数

[cpp] view plain copy
  1. PackageSetting getPackageLPw(PackageParser.Package pkg, PackageSetting origPackage,  
  2.         String realName, SharedUserSetting sharedUser, File codePath, File resourcePath,  
  3.         String legacyNativeLibraryPathString, String primaryCpuAbi, String secondaryCpuAbi,  
  4.         int pkgFlags, int pkgPrivateFlags, UserHandle user, boolean add) {  
  5.     final String name = pkg.packageName;  
  6.     PackageSetting p = getPackageLPw(name, origPackage, realName, sharedUser, codePath,  
  7.             resourcePath, legacyNativeLibraryPathString, primaryCpuAbi, secondaryCpuAbi,  
  8.             pkg.mVersionCode, pkgFlags, pkgPrivateFlags, user, add, true /* allowInstall */);  
  9.     return p;  
  10. }  

我们来看下这个函数，首先我们现在在mPackages没有值，所以直接从p==null分支看，然后也没有origPackage，没有sharedUser，我们就直接看newUserIdLPw函数产生一个新的uid。

[cpp] view plain copy
  1. private PackageSetting getPackageLPw(String name, PackageSetting origPackage,  
  2.         String realName, SharedUserSetting sharedUser, File codePath, File resourcePath,  
  3.         String legacyNativeLibraryPathString, String primaryCpuAbiString,  
  4.         String secondaryCpuAbiString, int vc, int pkgFlags, int pkgPrivateFlags,  
  5.         UserHandle installUser, boolean add, boolean allowInstall) {  
  6.     PackageSetting p = mPackages.get(name);  
  7.     UserManagerService userManager = UserManagerService.getInstance();  
  8.     if (p != null) {  
  9.         ......  
  10.     }  
  11.     if (p == null) {  
  12.         if (origPackage != null) {  
  13.             ......  
  14.         } else {  
  15.             p = new PackageSetting(name, realName, codePath, resourcePath,  
  16.                     legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,  
  17.                     null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags);  
  18.             p.setTimeStamp(codePath.lastModified());  
  19.             p.sharedUser = sharedUser;  
  20.             // If this is not a system app, it starts out stopped.  
  21.             if ((pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {  
  22.                 if (DEBUG_STOPPED) {  
  23.                     RuntimeException e = new RuntimeException("here");  
  24.                     e.fillInStackTrace();  
  25.                     Slog.i(PackageManagerService.TAG, "Stopping package " + name, e);  
  26.                 }  
  27.                 List users = getAllUsers();  
  28.                 final int installUserId = installUser != null ? installUser.getIdentifier() : 0;  
  29.                 if (users != null && allowInstall) {  
  30.                     for (UserInfo user : users) {  
  31.                         // By default we consider this app to be installed  
  32.                         // for the user if no user has been specified (which  
  33.                         // means to leave it at its original value, and the  
  34.                         // original default value is true), or we are being  
  35.                         // asked to install for all users, or this is the  
  36.                         // user we are installing for.  
  37.                         final boolean installed = installUser == null  
  38.                                 || (installUserId == UserHandle.USER_ALL  
  39.                                     && !isAdbInstallDisallowed(userManager, user.id))  
  40.                                 || installUserId == user.id;  
  41.                         p.setUserState(user.id, COMPONENT_ENABLED_STATE_DEFAULT,  
  42.                                 installed,  
  43.                                 true, // stopped,  
  44.                                 true, // notLaunched  
  45.                                 false, // hidden  
  46.                                 null, null, null,  
  47.                                 false, // blockUninstall  
  48.                                 INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED, 0);  
  49.                         writePackageRestrictionsLPr(user.id);  
  50.                     }  
  51.                 }  
  52.             }  
  53.             if (sharedUser != null) {//是否有sharedUser，这样就是在相同的uid下  
  54.                 p.appId = sharedUser.userId;  
  55.             } else {  
  56.                 // Clone the setting here for disabled system packages  
  57.                 PackageSetting dis = mDisabledSysPackages.get(name);//这里我们也不关注  
  58.                 if (dis != null) {  
  59.                     // For disabled packages a new setting is created  
  60.                     // from the existing user id. This still has to be  
  61.                     // added to list of user id's  
  62.                     // Copy signatures from previous setting  
  63.                     if (dis.signatures.mSignatures != null) {  
  64.                         p.signatures.mSignatures = dis.signatures.mSignatures.clone();  
  65.                     }  
  66.                     p.appId = dis.appId;  
  67.                     // Clone permissions  
  68.                     p.getPermissionsState().copyFrom(dis.getPermissionsState());  
  69.                     // Clone component info  
  70.                     List users = getAllUsers();  
  71.                     if (users != null) {  
  72.                         for (UserInfo user : users) {  
  73.                             int userId = user.id;  
  74.                             p.setDisabledComponentsCopy(  
  75.                                     dis.getDisabledComponents(userId), userId);  
  76.                             p.setEnabledComponentsCopy(  
  77.                                     dis.getEnabledComponents(userId), userId);  
  78.                         }  
  79.                     }  
  80.                     // Add new setting to list of user ids  
  81.                     addUserIdLPw(p.appId, p, name);  
  82.                 } else {  
  83.                     // Assign new user id  
  84.                     p.appId = newUserIdLPw(p);//分配一个新的uid  
  85.                 }  
  86.             }  
  87.         }  
  88.         if (p.appId < 0) {  
  89.             PackageManagerService.reportSettingsProblem(Log.WARN,  
  90.                     "Package " + name + " could not be assigned a valid uid");  
  91.             return null;  
  92.         }  
  93.         if (add) {  
  94.             // Finish adding new package by adding it and updating shared  
  95.             // user preferences  
  96.             addPackageSettingLPw(p, name, sharedUser);  
  97.         }  
  98.     } else {  
  99.         .....  
  100.     }  
  101.     return p;  
  102. }  

newUserIdLPw函数先遍历所有的uid。看哪个uid对应的对象空了，就重新用这个uid。如果都不为空，而且不超过最大uid值，用当前最大值的uid+1，作为新的uid。

[cpp] view plain copy
  1. private int newUserIdLPw(Object obj) {  
  2.     // Let's be stupidly inefficient for now...  
  3.     final int N = mUserIds.size();  
  4.     for (int i = mFirstAvailableUid; i < N; i++) {  
  5.         if (mUserIds.get(i) == null) {  
  6.             mUserIds.set(i, obj);  
  7.             return Process.FIRST_APPLICATION_UID + i;  
  8.         }  
  9.     }  
  10.   
  11.     // None left?  
  12.     if (N > (Process.LAST_APPLICATION_UID-Process.FIRST_APPLICATION_UID)) {  
  13.         return -1;  
  14.     }  
  15.   
  16.     mUserIds.add(obj);  
  17.     return Process.FIRST_APPLICATION_UID + N;  
  18. }  


六、成员变量mSettings mPackages保存数据

在scanPackageDirtyLI函数后面会保存mSettings和mPackages，主要是把PackageSetting保存在mSetting中，把Package保存在mPackages中。mPackages直接put了，我们就不分析了。我们看下mSettings保存PackageSetting。

[cpp] view plain copy
  1. synchronized (mPackages) {  
  2.     // We don't expect installation to fail beyond this point  
  3.   
  4.     // Add the new setting to mSettings  
  5.     mSettings.insertPackageSettingLPw(pkgSetting, pkg);  
  6.     // Add the new setting to mPackages  
  7.     mPackages.put(pkg.applicationInfo.packageName, pkg);  

insertPackageSettingLPw函数先把pkg赋给了PackageSetting 的pkg，最后调用了addPackageSettingLPw函数保存PackageSetting 对象。

[cpp] view plain copy
  1. void insertPackageSettingLPw(PackageSetting p, PackageParser.Package pkg) {  
  2.     p.pkg = pkg;  
  3.     // pkg.mSetEnabled = p.getEnabled(userId);  
  4.     // pkg.mSetStopped = p.getStopped(userId);  
  5.     final String volumeUuid = pkg.applicationInfo.volumeUuid;  
  6.     final String codePath = pkg.applicationInfo.getCodePath();  
  7.     final String resourcePath = pkg.applicationInfo.getResourcePath();  
  8.     final String legacyNativeLibraryPath = pkg.applicationInfo.nativeLibraryRootDir;  
  9.     // Update volume if needed  
  10.     if (!Objects.equals(volumeUuid, p.volumeUuid)) {  
  11.         Slog.w(PackageManagerService.TAG, "Volume for " + p.pkg.packageName +  
  12.                 " changing from " + p.volumeUuid + " to " + volumeUuid);  
  13.         p.volumeUuid = volumeUuid;  
  14.     }  
  15.     // Update code path if needed  
  16.     if (!Objects.equals(codePath, p.codePathString)) {  
  17.         Slog.w(PackageManagerService.TAG, "Code path for " + p.pkg.packageName +  
  18.                 " changing from " + p.codePathString + " to " + codePath);  
  19.         p.codePath = new File(codePath);  
  20.         p.codePathString = codePath;  
  21.     }  
  22.     //Update resource path if needed  
  23.     if (!Objects.equals(resourcePath, p.resourcePathString)) {  
  24.         Slog.w(PackageManagerService.TAG, "Resource path for " + p.pkg.packageName +  
  25.                 " changing from " + p.resourcePathString + " to " + resourcePath);  
  26.         p.resourcePath = new File(resourcePath);  
  27.         p.resourcePathString = resourcePath;  
  28.     }  
  29.     // Update the native library paths if needed  
  30.     if (!Objects.equals(legacyNativeLibraryPath, p.legacyNativeLibraryPathString)) {  
  31.         p.legacyNativeLibraryPathString = legacyNativeLibraryPath;  
  32.     }  
  33.   
  34.     // Update the required Cpu Abi  
  35.     p.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;  
  36.     p.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;  
  37.     p.cpuAbiOverrideString = pkg.cpuAbiOverride;  
  38.     // Update version code if needed  
  39.     if (pkg.mVersionCode != p.versionCode) {  
  40.         p.versionCode = pkg.mVersionCode;  
  41.     }  
  42.     // Update signatures if needed.  
  43.     if (p.signatures.mSignatures == null) {  
  44.         p.signatures.assignSignatures(pkg.mSignatures);  
  45.     }  
  46.     // Update flags if needed.  
  47.     if (pkg.applicationInfo.flags != p.pkgFlags) {  
  48.         p.pkgFlags = pkg.applicationInfo.flags;  
  49.     }  
  50.     // If this app defines a shared user id initialize  
  51.     // the shared user signatures as well.  
  52.     if (p.sharedUser != null && p.sharedUser.signatures.mSignatures == null) {  
  53.         p.sharedUser.signatures.assignSignatures(pkg.mSignatures);  
  54.     }  
  55.     addPackageSettingLPw(p, pkg.packageName, p.sharedUser);  
  56. }  
addPackageSettingLPw主要把PackageSetting 放在了mSettings的成员变量mPackages中。
[cpp] view plain copy
  1. private void addPackageSettingLPw(PackageSetting p, String name,  
  2.         SharedUserSetting sharedUser) {  
  3.     mPackages.put(name, p);  
  4. ..  
这里只是保存了这两个成员变量，而在每次开机的时候都会重新扫描各个目录的apk，然后重新把各个PackageSetting放入mSettings中，最后也会把mSettings中的数据写入packages.xml文件中。


七、总结

在AMS中我们从PKMS中通过Intent参数获取ActivityInfo对象，并且其processName和uid这两个变量在后续启动进程的时候很重要。而PKMS通过Intent查询Activity，如果Intent有ComponentName我们可以直接找到对应的Activity，并且把ActivityInfo传给AMS。如果没有ComponentName，就要通过包名或者全局查找了。

你可能感兴趣的:(Android,基础业务分析)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • JVM StackMapTable 属性的作用及理解 lijingyao8206 jvm字节码Class文件StackMapTable
            在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
  • 回调函数调用方法 百合不是茶 java
    最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记 记录一下   代码很简单:           MainDemo  :调用方法  得到方法的返回结果        
  • [时间机器]制造时间机器需要一些材料 comsci 制造
          根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质     和材料...       甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......      
  • 开口埋怨不如闭口做事 邓集海 邓集海 做人 做事 工作
    “开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。 　　 　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。 　　 　　
  • jQuery插件开发全解析，类级别与对象级别开发 IT独行者 jquery开发插件　函数
    jQuery插件的开发包括两种： 一种是类级别的插件开发，即给 jQuery添加新的全局函数，相当于给 jQuery类本身添加方法。 jQuery的全局函数就是属于 jQuery命名空间的函数，另一种是对象级别的插件开发，即给 jQuery对象添加方法。下面就两种函数的开发做详细的说明。   1 、类级别的插件开发 类级别的插件开发最直接的理解就是给jQuer
  • Rome解析Rss 413277409 Rome解析Rss
    import java.net.URL;  import java.util.List;    import org.junit.Test;    import com.sun.syndication.feed.synd.SyndCategory;  import com.sun.syndication.feed.synd.S
  • RSA加密解密 无量 加密解密rsa
    RSA加密解密代码 代码有待整理 package com.tongbanjie.commons.util; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerat
  • linux 软件安装遇到的问题 aichenglong linux遇到的问题ftp
    1 ftp配置中遇到的问题    500 OOPS: cannot change directory   出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了   修改方法:1 修改/etc/selinux/config 中SELINUX=disabled    2 source /etc
  • 面试心得 alafqq 面试
    最近面试了好几家公司。记录下； 支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败； 阿里金融，面试官人也挺和善，只不过我让他吐血了。。。 由于印象比较深，记录下； 1，自我介绍 2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型） 3，什么是包装类，包装类的优点； 4，平时看过什么书？NND，什么书都没看过。。照样
  • java的多态性探讨 百合不是茶 java
    java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况 //package 1; class A{ public void test(){ System.out.println("A"); } } class D extends A{ public void test(){ S
  • 网络编程基础篇之JavaScript-学习笔记 bijian1013 JavaScript
    1.documentWrite <html> <head> <script language="JavaScript"> document.write("这是电脑网络学校"); document.close(); </script> </h
  • 探索JUnit4扩展：深入Rule bijian1013 JUnitRule单元测试
            本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。         在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
  • [CSS]CSS浮动十五条规则 bit1129 css
    这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。   1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
  • 【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景 bit1129 partition
    0.Kafka服务器配置 3个broker 1个topic，6个partition，副本因子是2 2个consumer，每个consumer三个线程并发读取   1. Producer package kafka.examples.multibrokers.producers; import java.util.Properties; import java.util.
  • zabbix_agentd.conf配置文件详解 ronin47 zabbix 配置文件
    Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]， 或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
  • java--19.用矩阵求Fibonacci数列的第N项 bylijinnan fibonacci
    参考了网上的思路，写了个Java版的： public class Fibonacci { final static int[] A={1,1,1,0}; public static void main(String[] args) { int n=7; for(int i=0;i<=n;i++){ int f=fibonac
  • Netty源码学习-LengthFieldBasedFrameDecoder bylijinnan javanetty
    先看看LengthFieldBasedFrameDecoder的官方API http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下： 实
  • AES加密解密 chicony 加密解密
    AES加解密算法，使用Base64做转码以及辅助加密： package com.wintv.common; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decod
  • 文件编码格式转换 ctrain 编码格式
    package com.test; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;
  • mysql 在linux客户端插入数据中文乱码 daizj mysql中文乱码
    1、查看系统客户端，数据库，连接层的编码  查看方法： http://daizj.iteye.com/blog/2174993 进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+------
  • 好代码是廉价的代码 dcj3sjt126com 程序员读书
      长久以来我一直主张：好代码是廉价的代码。 当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。 当他们走近看我的表情、知道我是认真的时，才收敛一点。 当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。” 我只
  • Android网络请求库——android-async-http dcj3sjt126com android
    在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
  • ORACLE 复习笔记之SQL语句的优化 eksliang SQL优化Oracle sql语句优化SQL语句的优化
    转载请出自出处：http://eksliang.iteye.com/blog/2097999   SQL语句的优化总结如下   sql语句的优化可以按照如下六个步骤进行： 合理使用索引 避免或者简化排序 消除对大表的扫描 避免复杂的通配符匹配 调整子查询的性能 EXISTS和IN运算符 下面我就按照上面这六个步骤分别进行总结：
  • 浅析：Android 嵌套滑动机制（NestedScrolling） gg163 android移动开发滑动机制嵌套
    谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性 NestedScrolling的特性可以体现在哪里呢？<!--[if !supportLineBreakNewLine]--><!--[endif]--> 比如你使用了Toolbar，下面一个ScrollView，向上滚
  • 使用hovertree菜单作为后台导航 hvt JavaScriptjquery.nethovertreeasp.net
      hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。 0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm hovertree插件包含文件： http://keleyi.com/jq/hovertree/css
  • SVG 教程 （二）矩形 天梯梦 svg
    SVG <rect> SVG Shapes SVG有一些预定义的形状元素，可被开发者使用和操作： 矩形 <rect> 圆形 <circle> 椭圆 <ellipse> 线 <line> 折线 <polyline> 多边形 <polygon> 路径 <path>
  • 一个简单的队列 luyulong java数据结构队列
    public class MyQueue { private long[] arr; private int front; private int end; // 有效数据的大小 private int elements; public MyQueue() { arr = new long[10]; elements = 0; front
  • 基础数据结构和算法九：Binary Search Tree sunwinner Algorithm
      A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
  • 项目出现的一些问题和体会 Steven-Walker DAOWebservlet
         第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。     这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。 dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。  &
  • 高手问答：Java老A带你全面提升Java单兵作战能力！ ITeye管理员 java
    本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论! 作者简介： 淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。 CSDN博客地址： http://blog.csdn.net/xieyuooo 作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他