android8-0-0源码分析-app启动3

前言

本篇继续探索oat文件的加载。先补充些内容：

ApplicationThread与Application不同。
ActivityThread内mAppThread是一个ApplicationThread类型的Binder对象，它的作用是用来进行进程间通信的。其继承于IApplicationThread.Stub
Application是继承ContextWrapper的组件，表示app，同样存于ActivityThread内mInitialApplication全局唯一

参考文：
http://gityuan.com/2017/04/09/android_context/
https://shuwoom.com/?p=142

几个关键的类：

1. ActivityThread：主线程，通过接受AMS的请求对Activity等组件进行控制。因此可以及时控制app。
2. Application：代表app对象，LoadedApk对象存于其中。
3. Instrumentation：用来监控系统和应用的交互常用于测试。
4. LoadedApk：当前加载的APK包的各种信息

图

有些类的调用比较多因此省略图，但在文中会有体现

源码

1-handleBindApplication

handleBindApplication
frameworks\base\core\java\android\app\ActivityThread.java

    private void handleBindApplication(AppBindData data) {
......

		//创建Loadedapk
        data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);

......
		
		
		
        // Instrumentation info affects the class loader, so load it before
        // setting up the app context.
		//这里获取Instrumentation的信息，其实普通包不会声明这个
        final InstrumentationInfo ii;
        if (data.instrumentationName != null) {
            try {
                ii = new ApplicationPackageManager(null, getPackageManager())
                        .getInstrumentationInfo(data.instrumentationName, 0);
            } catch (PackageManager.NameNotFoundException e) {
                throw new RuntimeException(
                        "Unable to find instrumentation info for: " + data.instrumentationName);
            }

            mInstrumentationPackageName = ii.packageName;
            mInstrumentationAppDir = ii.sourceDir;
            mInstrumentationSplitAppDirs = ii.splitSourceDirs;
            mInstrumentationLibDir = getInstrumentationLibrary(data.appInfo, ii);
            mInstrumentedAppDir = data.info.getAppDir();
            mInstrumentedSplitAppDirs = data.info.getSplitAppDirs();
            mInstrumentedLibDir = data.info.getLibDir();
        } else {
            ii = null;
        }

		
		//创建ContextImpl对象
        final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
        updateLocaleListFromAppContext(appContext,
                mResourcesManager.getConfiguration().getLocales());

......


        // 这里加载Instrumentation。Instrumentation常用于测试，可以在工程文件中自己定义实现。
		//一般测试的Instrumentation是写在另一个apk中的，因此一般的到这里是null
        if (ii != null) {
            final ApplicationInfo instrApp = new ApplicationInfo();
            ii.copyTo(instrApp);
            instrApp.initForUser(UserHandle.myUserId());
            final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                    appContext.getClassLoader(), false, true, false);
            final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);

            try {
                final ClassLoader cl = instrContext.getClassLoader();
                mInstrumentation = (Instrumentation)
                    cl.loadClass(data.instrumentationName.getClassName()).newInstance();
            } catch (Exception e) {
                throw new RuntimeException(
                    "Unable to instantiate instrumentation "
                    + data.instrumentationName + ": " + e.toString(), e);
            }
......

        } else {
			//一般apk执行这里获取默认的Instrumentation
            mInstrumentation = new Instrumentation();
        }


		
		......
		
        try {
			//创建mInitialApplication并赋给了ActivityThread的默认权限属性  restrictedBackupMode表示是否默认application
            Application app = data.info.makeApplication(data.restrictedBackupMode, null);
            mInitialApplication = app;

            // don't bring up providers in restricted mode; they may depend on the
            // app's custom Application class
            if (!data.restrictedBackupMode) {
                if (!ArrayUtils.isEmpty(data.providers)) {
                    installContentProviders(app, data.providers);
                    // For process that contains content providers, we want to
                    // ensure that the JIT is enabled "at some point".
                    mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
                }
            }

            // Do this after providers, since instrumentation tests generally start their
            // test thread at this point, and we don't want that racing.
            try {
				//执行测试类的oncreate
                mInstrumentation.onCreate(data.instrumentationArgs);
            }
            catch (Exception e) {
                throw new RuntimeException(
                    "Exception thrown in onCreate() of "
                    + data.instrumentationName + ": " + e.toString(), e);
            }

            try {
				//执行Application.Create回调
                mInstrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
......
            }
        } finally {
            StrictMode.setThreadPolicy(savedPolicy);
        }
......

    }

instrumentation是一种典型的委托观察者模式，用该对象操作活动等可以检测活动。
其常用于测试，可在manifest文件中声明，定义。

<instrumentation
android:name="android.test.InstrumentationTestRunner"
android:targetPackage="com.xuxu.unittest" >
</instrumentation>

从上到下依次看：

2-getPackageInfoNoCheck

创建LoadedApk：
frameworks\base\core\java\android\app\ActivityThread.java

   public final LoadedApk getPackageInfoNoCheck(ApplicationInfo ai,
           CompatibilityInfo compatInfo) {
       return getPackageInfo(ai, compatInfo, null, false, true, false);
   }

//securityViolation=false,则不进行是否违反隐私的监测;
//includeCode为true
//registerPackage=false, 则在获取类加载器(getClassLoader)时,不会将该package添加到当前所在进程的成员变量pkgDeps.
   private LoadedApk getPackageInfo(ApplicationInfo aInfo, CompatibilityInfo compatInfo,
           ClassLoader baseLoader, boolean securityViolation, boolean includeCode,
           boolean registerPackage) {
       final boolean differentUser = (UserHandle.myUserId() != UserHandle.getUserId(aInfo.uid));
       synchronized (mResourcesManager) {
           WeakReference<LoadedApk> ref;
           if (differentUser) {
               // Caching not supported across users
               ref = null;
           } else if (includeCode) {
               ref = mPackages.get(aInfo.packageName);
           } else {
               ref = mResourcePackages.get(aInfo.packageName);
           }

           LoadedApk packageInfo = ref != null ? ref.get() : null;
           if (packageInfo == null || (packageInfo.mResources != null
                   && !packageInfo.mResources.getAssets().isUpToDate())) {
 
 
			//创建LoadedApk对象, 此时baseLoader为null
               packageInfo =
                   new LoadedApk(this, aInfo, compatInfo, baseLoader,
                           securityViolation, includeCode &&
                           (aInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0, registerPackage);
			//系统应用
               if (mSystemThread && "android".equals(aInfo.packageName)) {
                   packageInfo.installSystemApplicationInfo(aInfo,
                           getSystemContext().mPackageInfo.getClassLoader());
               }

               if (differentUser) {
                   // Caching not supported across users
               } else if (includeCode) {
                   mPackages.put(aInfo.packageName,
                           new WeakReference<LoadedApk>(packageInfo));
               } else {
                   mResourcePackages.put(aInfo.packageName,
                           new WeakReference<LoadedApk>(packageInfo));
               }
           }
           return packageInfo;
       }
   }

mPackages的数据类型为ArrayMap,记录着每一个包名所对应的LoadedApk对象的弱引用。
当mPackages没有找到相应的LoadedApk对象, 则创建该对象并加入到mPackages。这里初次创建。

4-LoadedApk

LoadedApk
frameworks\base\core\java\android\app\LoadedApk.java

public final class LoadedApk {
	static final String TAG = "LoadedApk";
    static final boolean DEBUG = false;

    private final ActivityThread mActivityThread;
    final String mPackageName;
    private ApplicationInfo mApplicationInfo;
    private String mAppDir;
    private String mResDir;
    private String[] mOverlayDirs;
    private String[] mSharedLibraries;
    private String mDataDir;
    private String mLibDir;
    private File mDataDirFile;
    private File mDeviceProtectedDataDirFile;
    private File mCredentialProtectedDataDirFile;
    private final ClassLoader mBaseClassLoader;
    private final boolean mSecurityViolation;
    private final boolean mIncludeCode;
    private final boolean mRegisterPackage;
    private final DisplayAdjustments mDisplayAdjustments = new DisplayAdjustments();
    /** WARNING: This may change. Don't hold external references to it. */
    Resources mResources;
    private ClassLoader mClassLoader;
    private Application mApplication;

    private String[] mSplitNames;
    private String[] mSplitAppDirs;
    private String[] mSplitResDirs;

    private final ArrayMap<Context, ArrayMap<BroadcastReceiver, ReceiverDispatcher>> mReceivers
        = new ArrayMap<>();
    private final ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>> mUnregisteredReceivers
        = new ArrayMap<>();
    private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mServices
        = new ArrayMap<>();
    private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mUnboundServices
        = new ArrayMap<>();

    int mClientCount = 0;
    /**
     * Create information about a new .apk
     *
     * NOTE: This constructor is called with ActivityThread's lock held,
     * so MUST NOT call back out to the activity manager.
     */
    public LoadedApk(ActivityThread activityThread, ApplicationInfo aInfo,
            CompatibilityInfo compatInfo, ClassLoader baseLoader,//null
            boolean securityViolation, boolean includeCode, boolean registerPackage) {

        mActivityThread = activityThread;
        setApplicationInfo(aInfo);
        mPackageName = aInfo.packageName;
        mBaseClassLoader = baseLoader;
        mSecurityViolation = securityViolation;
        mIncludeCode = includeCode;
        mRegisterPackage = registerPackage;
        mDisplayAdjustments.setCompatibilityInfo(compatInfo);
    }
    private void setApplicationInfo(ApplicationInfo aInfo) {
        final int myUid = Process.myUid();
        aInfo = adjustNativeLibraryPaths(aInfo);
        mApplicationInfo = aInfo;
        mAppDir = aInfo.sourceDir;
        mResDir = aInfo.uid == myUid ? aInfo.sourceDir : aInfo.publicSourceDir;
        mOverlayDirs = aInfo.resourceDirs;
        mSharedLibraries = aInfo.sharedLibraryFiles;
        mDataDir = aInfo.dataDir;
        mLibDir = aInfo.nativeLibraryDir;
        mDataDirFile = FileUtils.newFileOrNull(aInfo.dataDir);
        mDeviceProtectedDataDirFile = FileUtils.newFileOrNull(aInfo.deviceProtectedDataDir);
        mCredentialProtectedDataDirFile = FileUtils.newFileOrNull(aInfo.credentialProtectedDataDir);

        mSplitNames = aInfo.splitNames;
        mSplitAppDirs = aInfo.splitSourceDirs;
        mSplitResDirs = aInfo.uid == myUid ? aInfo.splitSourceDirs : aInfo.splitPublicSourceDirs;

        if (aInfo.requestsIsolatedSplitLoading() && !ArrayUtils.isEmpty(mSplitNames)) {
            mSplitLoader = new SplitDependencyLoaderImpl(aInfo.splitDependencies);
        }
    }
}

对象的属性赋予。baseLoader为null
一个应用程序对应一个LoadedApk对象。它用来保存当前加载的APK包的各种信息，包括app安装路径、资源路径、用户数据保存路径、使用的类加载器、Application信息等。
!!这几个值需要打印下看下具体路径!!

Instrumentation

默认的Instrumentation：

   public Instrumentation() {
   }


public void onCreate(Bundle arguments) {
   }

都是空….因为是测试类要实现的，用于在正常回调前执行。

7-makeApplication

data.info.makeApplication
frameworks\base\core\java\android\app\LoadedApk.java

  public Application makeApplication(boolean forceDefaultAppClass,
          Instrumentation instrumentation) {
      if (mApplication != null) {
          return mApplication;
      }

      Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");

      Application app = null;

//默认application或者没有className就用默认的Application
      String appClass = mApplicationInfo.className;
      if (forceDefaultAppClass || (appClass == null)) {
          appClass = "android.app.Application";
      }

      try {
	//获取ClassLoader
          java.lang.ClassLoader cl = getClassLoader();
          if (!mPackageName.equals("android")) {
              Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                      "initializeJavaContextClassLoader");
              initializeJavaContextClassLoader();
              Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
          }
	
	
	//创建ContextImpl对象
          ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
	//创建Application对象, 并将appContext attach到新创建的Application
          app = mActivityThread.mInstrumentation.newApplication(
                  cl, appClass, appContext);
          appContext.setOuterContext(app);
      } catch (Exception e) {
          if (!mActivityThread.mInstrumentation.onException(app, e)) {
              Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
              throw new RuntimeException(
                  "Unable to instantiate application " + appClass
                  + ": " + e.toString(), e);
          }
      }
      mActivityThread.mAllApplications.add(app);
      mApplication = app;

//这里是null
      if (instrumentation != null) {
          try {
              instrumentation.callApplicationOnCreate(app);
          } catch (Exception e) {
              if (!instrumentation.onException(app, e)) {
                  Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                  throw new RuntimeException(
                      "Unable to create application " + app.getClass().getName()
                      + ": " + e.toString(), e);
              }
          }
      }

      // Rewrite the R 'constants' for all library apks.
      SparseArray<String> packageIdentifiers = getAssets().getAssignedPackageIdentifiers();
      final int N = packageIdentifiers.size();
      for (int i = 0; i < N; i++) {
          final int id = packageIdentifiers.keyAt(i);
          if (id == 0x01 || id == 0x7f) {
              continue;
          }

          rewriteRValues(getClassLoader(), packageIdentifiers.valueAt(i), id);
      }

      Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

      return app;
  }

LoadedApk中存有应用解析出的各种信息。这里获取ClassLoader、创建ContextImpl对象、创建Application对象并attach。

顺路把createAppContext看一下
frameworks\base\core\java\android\app\ContextImpl.java

    static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
        if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                null);
        context.setResources(packageInfo.getResources());
        return context;
    }
	
	private ContextImpl(@Nullable ContextImpl container, @NonNull ActivityThread mainThread,
            @NonNull LoadedApk packageInfo, @Nullable String splitName,
            @Nullable IBinder activityToken, @Nullable UserHandle user, int flags,
            @Nullable ClassLoader classLoader) {
        mOuterContext = this;//ContextImpl对象

......

        mMainThread = mainThread; // ActivityThread赋值
        mActivityToken = activityToken;
        mFlags = flags;

        if (user == null) {
            user = Process.myUserHandle();
        }
        mUser = user;

        mPackageInfo = packageInfo;// LoadedApk赋值
        mSplitName = splitName;
        mClassLoader = classLoader;
        mResourcesManager = ResourcesManager.getInstance();

        if (container != null) {
.....
        } else {
            mBasePackageName = packageInfo.mPackageName;
            ApplicationInfo ainfo = packageInfo.getApplicationInfo();
            if (ainfo.uid == Process.SYSTEM_UID && ainfo.uid != Process.myUid()) {
                // Special case: system components allow themselves to be loaded in to other
                // processes.  For purposes of app ops, we must then consider the context as
                // belonging to the package of this process, not the system itself, otherwise
                // the package+uid verifications in app ops will fail.
                mOpPackageName = ActivityThread.currentPackageName();
            } else {
                mOpPackageName = mBasePackageName;
            }
        }

        mContentResolver = new ApplicationContentResolver(this, mainThread, user);
    }
	
	final void setOuterContext(Context context) {
        mOuterContext = context;
    }

到此为止简单总结下Context是什么。通过其使用与构造可以看出就是如其所意：上下文，存储着运行环境的相关信息。并设定其运行场景可执行的不同方法。
ContextImpl:
Application/Activity/Service通过attach() 调用父类ContextWrapper的attachBaseContext(), 从而设置父类成员变量mBase为ContextImpl对象;
ContextWrapper的核心工作都是交给mBase(即ContextImpl)来完成;

13-newApplication

mInstrumentation.newApplication
frameworks\base\core\java\android\app\Instrumentation.java

  public Application newApplication(ClassLoader cl, String className, Context context)
          throws InstantiationException, IllegalAccessException, 
          ClassNotFoundException {
      return newApplication(cl.loadClass(className), context);
  }
	
   static public Application newApplication(Class<?> clazz, Context context)
          throws InstantiationException, IllegalAccessException, 
          ClassNotFoundException {
		
		//反射创建对象
      Application app = (Application)clazz.newInstance();
//这里执行力application的第一个方法！attach！
      app.attach(context);
      return app;
  }

通过classloader加载类创建对象。

frameworks\base\core\java\android\app\Application.java

    /* package */ final void attach(Context context) {
        attachBaseContext(context);
        mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
    }
	
	
	
	
//D:\androidwsp\android8.0.0_r1\android-8.0.0_r1\frameworks\base\core\java\android\content\ContextWrapper.java
	protected void attachBaseContext(Context base) {
        if (mBase != null) {
            throw new IllegalStateException("Base context already set");
        }
        mBase = base;
    }

1. 将新创建的ContextImpl对象保存到Application的父类成员变量mBase;
2. 将当前所在的LoadedApk对象保存到Application的父员变量mLoadedApk;

保护时常重写attachBaseContext方法！！！！！！！

9-createOrUpdateClassLoaderLocked

getClassLoader
frameworks\base\core\java\android\app\LoadedApk.java

  public ClassLoader getClassLoader() {
      synchronized (this) {
	//到这里确实是null，mClassLoader存于LoadedApk对象中
          if (mClassLoader == null) {
              createOrUpdateClassLoaderLocked(null /*addedPaths*/);
          }
          return mClassLoader;
      }
  }

	
	
  private void createOrUpdateClassLoaderLocked(List<String> addedPaths) {
//系统应用
      if (mPackageName.equals("android")) {
          // Note: This branch is taken for system server and we don't need to setup
          // jit profiling support.
          if (mClassLoader != null) {
              // nothing to update
              return;
          }
	//mBaseClassLoader=null
          if (mBaseClassLoader != null) {
              mClassLoader = mBaseClassLoader;
          } else {
              mClassLoader = ClassLoader.getSystemClassLoader();
          }

          return;
      }

      // Avoid the binder call when the package is the current application package.
      // The activity manager will perform ensure that dexopt is performed before
      // spinning up the process.
//当包不是当前的应用程序包时
      if (!Objects.equals(mPackageName, ActivityThread.currentPackageName()) && mIncludeCode) {
          try {
              ActivityThread.getPackageManager().notifyPackageUse(mPackageName,
                      PackageManager.NOTIFY_PACKAGE_USE_CROSS_PACKAGE);
          } catch (RemoteException re) {
              throw re.rethrowFromSystemServer();
          }
      }

      if (mRegisterPackage) {
          try {
              ActivityManager.getService().addPackageDependency(mPackageName);
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }

      // Lists for the elements of zip/code and native libraries.
      //
      // Both lists are usually not empty. We expect on average one APK for the zip component,
      // but shared libraries and splits are not uncommon. We expect at least three elements
      // for native libraries (app-based, system, vendor). As such, give both some breathing
      // space and initialize to a small value (instead of incurring growth code).
      final List<String> zipPaths = new ArrayList<>(10);
      final List<String> libPaths = new ArrayList<>(10);

      final boolean isBundledApp = mApplicationInfo.isSystemApp()
              && !mApplicationInfo.isUpdatedSystemApp();

//这里添加data/app/xxx/下的目录
      makePaths(mActivityThread, isBundledApp, mApplicationInfo, zipPaths, libPaths);

      String libraryPermittedPath = mDataDir;
      if (isBundledApp) {
          // This is necessary to grant bundled apps access to
          // libraries located in subdirectories of /system/lib
          libraryPermittedPath += File.pathSeparator +
                                  System.getProperty("java.library.path");
      }

      final String librarySearchPath = TextUtils.join(File.pathSeparator, libPaths);

      // If we're not asked to include code, we construct a classloader that has
      // no code path included. We still need to set up the library search paths
      // and permitted path because NativeActivity relies on it (it attempts to
      // call System.loadLibrary() on a classloader from a LoadedApk with
      // mIncludeCode == false).
//不含代码执行
      if (!mIncludeCode) {
          if (mClassLoader == null) {
              StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
              mClassLoader = ApplicationLoaders.getDefault().getClassLoader(
                  "" /* codePath */, mApplicationInfo.targetSdkVersion, isBundledApp,
                  librarySearchPath, libraryPermittedPath, mBaseClassLoader);
              StrictMode.setThreadPolicy(oldPolicy);
          }

          return;
      }

      /*
       * With all the combination done (if necessary, actually create the java class
       * loader and set up JIT profiling support if necessary.
       *
       * In many cases this is a single APK, so try to avoid the StringBuilder in TextUtils.
       */
 //这个就是app需要加载的文件目录了
      final String zip = (zipPaths.size() == 1) ? zipPaths.get(0) :
              TextUtils.join(File.pathSeparator, zipPaths);

      if (DEBUG) Slog.v(ActivityThread.TAG, "Class path: " + zip +
                  ", JNI path: " + librarySearchPath);

      boolean needToSetupJitProfiles = false;

//这里是应用调用的地方
      if (mClassLoader == null) {
          // Temporarily disable logging of disk reads on the Looper thread
          // as this is early and necessary.
          StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();

          mClassLoader = ApplicationLoaders.getDefault().getClassLoader(zip,
                  mApplicationInfo.targetSdkVersion, isBundledApp, librarySearchPath,
                  libraryPermittedPath, mBaseClassLoader);

          StrictMode.setThreadPolicy(oldPolicy);
          // Setup the class loader paths for profiling.
          needToSetupJitProfiles = true;
      }

      if (addedPaths != null && addedPaths.size() > 0) {
          final String add = TextUtils.join(File.pathSeparator, addedPaths);
          ApplicationLoaders.getDefault().addPath(mClassLoader, add);
          // Setup the new code paths for profiling.
          needToSetupJitProfiles = true;
      }

      // Setup jit profile support.
      //
      // It is ok to call this multiple times if the application gets updated with new splits.
      // The runtime only keeps track of unique code paths and can handle re-registration of
      // the same code path. There's no need to pass `addedPaths` since any new code paths
      // are already in `mApplicationInfo`.
      //
      // It is NOT ok to call this function from the system_server (for any of the packages it
      // loads code from) so we explicitly disallow it there.
      if (needToSetupJitProfiles && !ActivityThread.isSystem()) {
          setupJitProfileSupport();
      }
  }

在这里mClassLoader为null，第三方应用且includecode为true，经过判断各项包的属性进入：
mClassLoader = ApplicationLoaders.getDefault().getClassLoader(zip,mApplicationInfo.targetSdkVersion, isBundledApp, librarySearchPath,libraryPermittedPath, mBaseClassLoader);

10-getClassLoader

frameworks\base\core\java\android\app\ApplicationLoaders.java

private final ArrayMap<String, ClassLoader> mLoaders = new ArrayMap<String, ClassLoader>();
private static final ApplicationLoaders gApplicationLoaders = new ApplicationLoaders();//默认构造函数



   public static ApplicationLoaders getDefault() {
       return gApplicationLoaders;
   }


ClassLoader getClassLoader(String zip, int targetSdkVersion, boolean isBundled,
                              String librarySearchPath, String libraryPermittedPath,
                              ClassLoader parent) {
       // For normal usage the cache key used is the same as the zip path.
       return getClassLoader(zip, targetSdkVersion, isBundled, librarySearchPath,
                             libraryPermittedPath, parent, zip);
   }


   private ClassLoader getClassLoader(String zip, int targetSdkVersion, boolean isBundled,
                                      String librarySearchPath, String libraryPermittedPath,
                                      ClassLoader parent, String cacheKey) {
       /*
        * This is the parent we use if they pass "null" in.  In theory
        * this should be the "system" class loader; in practice we
        * don't use that and can happily (and more efficiently) use the
        * bootstrap class loader.
        */
	//这里获取的是：
	/*
	private static ClassLoader createSystemClassLoader() {
	//获取默认的path
       String classPath = System.getProperty("java.class.path", ".");
       String librarySearchPath = System.getProperty("java.library.path", "");
	//构造了一个PathClassLoader，父用BootClassLoader
       return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());//BootClassLoader是静态唯一的。
   }
	
	*/
       ClassLoader baseParent = ClassLoader.getSystemClassLoader().getParent();

       synchronized (mLoaders) {
           if (parent == null) {
               parent = baseParent;
           }

           /*
            * If we're one step up from the base class loader, find
            * something in our cache.  Otherwise, we create a whole
            * new ClassLoader for the zip archive.
            */
           if (parent == baseParent) {
			
			//以前没存过
               ClassLoader loader = mLoaders.get(cacheKey);
               if (loader != null) {
                   return loader;
               }

               Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);

               PathClassLoader pathClassloader = PathClassLoaderFactory.createClassLoader(
                                                     zip,
                                                     librarySearchPath,
                                                     libraryPermittedPath,
                                                     parent,
                                                     targetSdkVersion,
                                                     isBundled);

               Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

               Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setupVulkanLayerPath");
               setupVulkanLayerPath(pathClassloader, librarySearchPath);
               Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

               mLoaders.put(cacheKey, pathClassloader);
               return pathClassloader;
           }

           Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);
           PathClassLoader pathClassloader = new PathClassLoader(zip, parent);
           Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
           return pathClassloader;
       }
   }

从缓存中获取，没有的话就新建并添加缓存，parent为默认创建的PathClassLoader

11-createClassLoader

createClassLoader
frameworks\base\core\java\com\android\internal\os\PathClassLoaderFactory.java

   public static PathClassLoader createClassLoader(String dexPath,
                                                   String librarySearchPath,
                                                   String libraryPermittedPath,
                                                   ClassLoader parent,
                                                   int targetSdkVersion,
                                                   boolean isNamespaceShared) {
													
														//需要加载的文件目录，lib，父
       PathClassLoader pathClassloader = new PathClassLoader(dexPath, librarySearchPath, parent);

       Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "createClassloaderNamespace");
       String errorMessage = createClassloaderNamespace(pathClassloader,
                                                        targetSdkVersion,
                                                        librarySearchPath,
                                                        libraryPermittedPath,
                                                        isNamespaceShared);
       Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

       if (errorMessage != null) {
           throw new UnsatisfiedLinkError("Unable to create namespace for the classloader " +
                                          pathClassloader + ": " + errorMessage);
       }

       return pathClassloader;
   }

private static native String createClassloaderNamespace(ClassLoader classLoader,
                                                           int targetSdkVersion,
                                                           String librarySearchPath,
                                                           String libraryPermittedPath,
                                                           boolean isNamespaceShared);

正式创建PathClassLoader就在这里。

15-callApplicationOnCreate

frameworks\base\core\java\android\app\Instrumentation.java

public void callApplicationOnCreate(Application app) {
    app.onCreate();
}

后记

android架构逐渐明朗，ActivityThread受到AMS的BindApplication命令后，用AMS传来的应用信息创建LoadedApk，application，Instrumentation等单例对象。
重点放在classloader的创建和类查找执行上，下一篇进入classloader。