Android资源访问机制

雨点打透心脏的1/2处 2021-06-26 16:06 392阅读 0赞

Android经常使用`getResources()`方法获取app的一些资源，`getResource（）`方法是`Context`接口的方法，具体是有`ContextImpl`类实现的，`Activity、Service、Application`都是继承自`Context`接口。

资源获取的方式是`context.getResources`，而真正的实现位于`ContextImpl`中的`getResources`方法，在`ContextImpl`中有一个私有成员`Resources mResources`，`getResources`方法返回的结果就是该对象成员，`mResources`的赋值则是在`ContextImpl`的构造函数中：

private ContextImpl(ContextImpl container, ActivityThread mainThread,
          LoadedApk packageInfo, IBinder activityToken, UserHandle user, Boolean restricted,
          Display display, Configuration overrideConfiguration) { 
    	.......
    	  Resources resources = packageInfo.getResources(mainThread);
    	if (resources != null) { 
    		if (activityToken != null
    		              || displayId != Display.DEFAULT_DISPLAY
    		              || overrideConfiguration != null
    		              || (compatInfo != null && compatInfo.applicationScale
    		                      != resources.getCompatibilityInfo().applicationScale)) { 
    			resources = mResourcesManager.getTopLevelResources(packageInfo.getResDir(),
    			                  packageInfo.getSplitResDirs(), packageInfo.getOverlayDirs(),
    			                  packageInfo.getApplicationInfo().sharedLibraryFiles, displayId,
    			                  overrideConfiguration, compatInfo, activityToken);
    		}
    	}
    	mResources = resources;

而`mPackageInfo`是`LoadedAPK`类，所以就是调用到`LoadedAPK`的`getResource（ActivityThread）`方法中：

public Resources  getResources(ActivityThread mainThread) { 
    	if (mResources == null) { 
    		mResources = mainThread.getTopLevelResources(mResDir, mSplitResDirs, mOverlayDirs,
    		                 mApplicationInfo.sharedLibraryFiles, Display.DEFAULT_DISPLAY, null, this);
    	}
    	return mResources;
    }

而`ActivityThread`类型的`mainThread`一个应用中只有一个，函数调用如下

Resources getTopLevelResources(String resDir, String[] splitResDirs, String[] overlayDirs,
           String[] libDirs, int displayId, Configuration overrideConfiguration,
           LoadedApk pkgInfo) { 
    	return mResourcesManager.getTopLevelResources(resDir, splitResDirs, overlayDirs, libDirs,
    	           displayId, overrideConfiguration, pkgInfo.getCompatibilityInfo(), null);
    }

下面看一下`ResourcesManager`的`getTopLevelResources`方法，

public Resources getTopLevelResources(String resDir, String[] splitResDirs,
            String[] overlayDirs, String[] libDirs, 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();
    	// resDir can be null if the 'android' package is creating a new Resources object.
    	// This is fine, since each AssetManager automatically loads the 'android' package
    	// already.
    	if (resDir != null) { 
    		if (assets.addAssetPath(resDir) == 0) { 
    			return null;
    		}
    	}
    	if (splitResDirs != null) { 
    		for (String splitResDir : splitResDirs) { 
    			if (assets.addAssetPath(splitResDir) == 0) { 
    				return null;
    			}
    		}
    	}
    	if (overlayDirs != null) { 
    		for (String idmapPath : overlayDirs) { 
    			assets.addOverlayPath(idmapPath);
    		}
    	}
    	if (libDirs != null) { 
    		for (String libDir : libDirs) { 
    			if (assets.addAssetPath(libDir) == 0) { 
    				Slog.w(TAG, "Asset path '" + libDir +
    				                        "' does not exist or contains no resources.");
    			}
    		}
    	}
    	//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;
    	}
    }

这个方法的思想是这样的：在`ResourcesManager`中，所有的资源对象都被存储在`ArrayMap`中，首先根据当前的请求参数去查找资源，如果找到了就返回；否则就创建一个资源对象放到`ArrayMap`中。为什么会有多个资源对象，因为`res`下可能存在多个适配不同设备、不同分辨率、不同系统版本的目录，按照`android`系统的设计，不同设备在访问同一个应用的时候访问的资源可以不同，比如`drawable-hdpi`和`drawable-xhdpi`就是典型的例子。

根据上述代码和`ResourcesManager`采用单例模式，这样就保证了不同的`ContextImpl`访问的是同一套资源，注意，这里说的同一套资源未必是同一个资源，因为资源可能位于不同的目录，但它一定是我们的应用的资源。或许这样来描述更准确，在设备参数和显示参数不变的情况下，不同的ContextImpl访问到的是同一份资源。设备参数不变是指手机的屏幕和android版本不变，显示参数不变是指手机的分辨率和横竖屏状态。也就是说，尽管Application、Activity、Service都有自己的`ContextImpl`，并且每个`ContextImpl`都有自己的`mResources`成员，但是由于它们的`mResources`成员都来自于唯一的`ResourcesManager`实例，所以它们看似不同的`mResources`其实都指向的是同一块内存(C语言的概念)，因此，它们的`mResources`都是同一个对象（在设备参数和显示参数不变的情况下）。在横竖屏切换的情况下且应用中为横竖屏状态提供了不同的资源，处在横屏状态下的`ContextImpl`和处在竖屏状态下的`ContextImpl`访问的资源不是同一个资源对象。

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

## `Resources`对象的创建过程 ##

通过阅读`Resources`类的源码可以知道，`Resources`对资源的访问实际上是通过`AssetManager`来实现的，那么如何创建一个`Resources`对象呢，有人会问，我为什么要去创建一个`Resources`对象呢，直接`getResources`不就可以了吗？我要说的是在某些特殊情况下你的确需要去创建一个资源对象，比如动态加载`apk`。很简单，首先看一下它的几个构造方法：

public Resources (AssetManager assets, DisplayMetrics metrics, Configuration config) { 
    	this(assets, metrics, config, CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
    }
    
    public Resources(AssetManager assets, DisplayMetrics metrics, Configuration config,
             CompatibilityInfo compatInfo, IBinder token) { 
    	mAssets = assets;
    	mMetrics.setToDefaults();
    	if (compatInfo != null) { 
    		mCompatibilityInfo = compatInfo;
    	}
    	mToken = new WeakReference<IBinder>(token);
    	updateConfiguration(config, metrics);
    	assets.ensureStringBlocks();
    }

从简单起见，我们应该采用第一个`public Resources(AssetManager assets, DisplayMetrics metrics, Configuration config)`

它接受3个参数，第一个是`AssetManager`，后面两个是和设备相关的配置参数，我们可以直接用当前应用的配置就好，所以，问题的关键在于如何创建`AssetManager`，下面请看分析，为了创建一个我们自己的`AssetManager`，我们先去看看系统是怎么创建的。还记得`getResources`的底层实现吗，在`ResourcesManager`的`getTopLevelResources`方法中有这么两句：

AssetManager assets = new AssetManager();  
        if (assets.addAssetPath(resDir) == 0) {   
            return null;  
        }

这两句就是创建一个`AssetManager`对象，后面会用这个对象来创建`Resources`对象，`AssetManager`就是这么创建的，`assets.addAssetPath(resDir)`这句话的意思是把资源目录里的资源都加载到`AssetManager`对象中，具体的实现在`jni`中，大家感兴趣自己去了解下。而资源目录就是我们的`res`目录，当然`resDir`可以是一个目录也可以是一个`zip`文件。有没有想过，如果我们把一个未安装的`apk`的路径传给这个方法，那么apk中的资源是不是就被加载到`AssetManager`对象里面了呢？事实证明，的确是这样。`addAssetPath`方法的定义如下，注意到它的注释里面有一个`{@hide}`关键字，这意味着即使它只是给`Framework`自己使用的，因此只能通过反射来调用。

public final int addedAssetPath(String path) { 
    	synchronized (this) { 
    		int res = addAssetPathNative(path);
    		makeStringBlocks(mStringBlocks);
    		return res;
    	}
    }

有了`AssetManager`对象后，我们就可以创建自己的`Resources`对象了，代码如下:

try { 
    	AssetManager assetManager = AssetManager.class.newInstance();
    	Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
    	addAssetPath.invoke(assetManager, mDexPath);
    	mAssetManager = assetManager;
    }
    catch (Exception e) { 
    	e.printStackTrace();
    }
    Resources currentRes = this.getResources();
    mResources = new Resources(mAssetManager, currentRes.getDisplayMetrics(), currentRes.getConfiguration());

有了`Resources`对象，我们就可以通过`Resources`对象来访问里面的各种资源了，通过这种方法，我们可以完成一些特殊的功能，比如换肤、换语言包、动态加载apk等。

另外，除了通过`Context`的`getResource()`方法访问android应用的资源外，还可以通过`PackageManger`来获取。

`PackageManager`本身只是一个抽象类，具体是由`ApplicationPackageManager`实现的，获取了`PackageManager`以后就可以调用`PacakageManager`的`getResourcesForApplication(ApplicationInfo app)`来获取`Resources`对象了，代码如下：

public Resources getResourcesForApplication(
         ApplicationInfo app) throws NameNotFoundException { 
    	if (app.packageName.equals("system")) { 
    		return mContext.mMainThread.getSystemContext().getResources();
    	}
    	final Boolean sameUid = (app.uid == Process.myUid());
    	Resources r = mContext.mMainThread.getTopLevelResources(
    	             sameUid ? app.sourceDir : app.publicSourceDir,
    	             sameUid ? app.splitSourceDirs : app.splitPublicSourceDirs,
    	             app.resourceDirs, app.sharedLibraryFiles, Display.DEFAULT_DISPLAY,
    	             null, mContext.mPackageInfo);
    	if (r != null) { 
    		return r;
    	}
    	throw new NameNotFoundException("Unable to open " + app.publicSourceDir);
    }

其实`PackageManager`方式同`Context`方式最终还是一致的，都是通过`mMainThread.getTopLevelResource()`方法来获取`Resources`的。