private final void handleBindApplication(AppBindData data) { 
    mBoundApplication = data; 
    mConfiguration = new Configuration(data.config); 
 
    .... 
    data.info = getPackageInfoNoCheck(data.appInfo); 
 
      ... 
     
    Application app = data.info.makeApplication(data.restrictedBackupMode, null); 
    mInitialApplication = app; 
 
   .... 
 } 

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

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())) { 
        if (localLOGV) Slog.v(TAG, (includeCode ? "Loading code package " 
            : "Loading resource-only package ") + aInfo.packageName 
            + " (in " + (mBoundApplication != null 
                ? mBoundApplication.processName : null) 
            + ")"); 
        packageInfo = 
          new LoadedApk(this, aInfo, this, baseLoader, 
              securityViolation, includeCode && 
              (aInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0); 
if (includeCode) { 
          mPackages.put(aInfo.packageName, 
              new WeakReference<LoadedApk>(packageInfo)); 
        } else { 
          mResourcePackages.put(aInfo.packageName, 
              new WeakReference<LoadedApk>(packageInfo)); 
        } 

try { 
      java.lang.ClassLoader cl = getClassLoader(); 
      //創(chuàng)建一個(gè)ContextImpl對(duì)象 
      ContextImpl appContext = new ContextImpl(); 
      appContext.init(this, null, mActivityThread); 
      app = mActivityThread.mInstrumentation.newApplication( 
          cl, appClass, appContext); 
      appContext.setOuterContext(app); 
    } catch (Exception e) { 
      if (!mActivityThread.mInstrumentation.onException(app, e)) { 
        throw new RuntimeException( 
          "Unable to instantiate application " + appClass 
          + ": " + e.toString(), e); 
      } 
    } 

mPackageInfo = packageInfo; 
mResources = mPackageInfo.getResources(mainThread); 

r.packageInfo= getPackageInfo(aInfo.applicationInfo,
          Context.CONTEXT_INCLUDE_CODE);
 
ContextImplappContext = new ContextImpl();
        appContext.init(r.packageInfo,r.token, this);
        appContext.setOuterContext(activity);
 
activity.attach(appContext,this, getInstrumentation(), r.token,
            r.ident, app, r.intent,r.activityInfo, title, r.parent,
            r.embeddedID,r.lastNonConfigurationInstance,
            r.lastNonConfigurationChildInstances, config);

LoadedApkpackageInfo = getPackageInfoNoCheck(
        data.info.applicationInfo);
 
ContextImplcontext = new ContextImpl();
      context.init(packageInfo, null,this);
 
      Application app =packageInfo.makeApplication(false, mInstrumentation);
      context.setOuterContext(service);
      service.attach(context, this,data.info.name, data.token, app,
          ActivityManagerNative.getDefault());

mResources = mResourcesManager.getTopLevelResources(mPackageInfo.getResDir(),
          Display.DEFAULT_DISPLAY, null, compatInfo, activityToken);

public Resources getTopLevelResources(String resDir, int displayId, 
    Configuration overrideConfiguration, CompatibilityInfo compatInfo, IBinder token) { 
  final float scale = compatInfo.applicationScale; 
  ResourcesKey key = new ResourcesKey(resDir, displayId, overrideConfiguration, scale, 
      token); 
  Resources r; 
  synchronized (this) { 
    // Resources is app scale dependent. 
    if (false) { 
      Slog.w(TAG, "getTopLevelResources: " + resDir + " / " + scale); 
    } 
    WeakReference<Resources> wr = mActiveResources.get(key); 
    r = wr != null ? wr.get() : null; 
    //if (r != null) Slog.i(TAG, "isUpToDate " + resDir + ": " + r.getAssets().isUpToDate()); 
    if (r != null && r.getAssets().isUpToDate()) { 
      if (false) { 
        Slog.w(TAG, "Returning cached resources " + r + " " + resDir 
            + ": appScale=" + r.getCompatibilityInfo().applicationScale); 
      } 
      return r; 
    } 
  } 
 
  //if (r != null) { 
  //  Slog.w(TAG, "Throwing away out-of-date resources!!!! " 
  //      + r + " " + resDir); 
  //} 
 
  AssetManager assets = new AssetManager(); 
  if (assets.addAssetPath(resDir) == 0) { 
    return null; 
  } 
 
  //Slog.i(TAG, "Resource: key=" + key + ", display metrics=" + metrics); 
  DisplayMetrics dm = getDisplayMetricsLocked(displayId); 
  Configuration config; 
  boolean isDefaultDisplay = (displayId == Display.DEFAULT_DISPLAY); 
  final boolean hasOverrideConfig = key.hasOverrideConfiguration(); 
  if (!isDefaultDisplay || hasOverrideConfig) { 
    config = new Configuration(getConfiguration()); 
    if (!isDefaultDisplay) { 
      applyNonDefaultDisplayMetricsToConfigurationLocked(dm, config); 
    } 
    if (hasOverrideConfig) { 
      config.updateFrom(key.mOverrideConfiguration); 
    } 
  } else { 
    config = getConfiguration(); 
  } 
  r = new Resources(assets, dm, config, compatInfo, token); 
  if (false) { 
    Slog.i(TAG, "Created app resources " + resDir + " " + r + ": " 
        + r.getConfiguration() + " appScale=" 
        + r.getCompatibilityInfo().applicationScale); 
  } 
 
  synchronized (this) { 
    WeakReference<Resources> wr = mActiveResources.get(key); 
    Resources existing = wr != null ? wr.get() : null; 
    if (existing != null && existing.getAssets().isUpToDate()) { 
      // Someone else already created the resources while we were 
      // unlocked; go ahead and use theirs. 
      r.getAssets().close(); 
      return existing; 
    } 
 
    // XXX need to remove entries when weak references go away 
    mActiveResources.put(key, new WeakReference<Resources>(r)); 
    return r; 
  } 
} 

public static ResourcesManager getInstance() { 
  synchronized (ResourcesManager.class) { 
    if (sResourcesManager == null) { 
      sResourcesManager = new ResourcesManager(); 
    } 
    return sResourcesManager; 
  } 
} 

  final ArrayList<Application> mAllApplications = new ArrayList<Application>();

@Override 
public Context getApplicationContext() { 
  return (mPackageInfo != null) ? 
      mPackageInfo.getApplication() : mMainThread.getApplication(); 
}