Android skinning principle and Android-Skin-Loader framework analysis

Android skinning technology has been a mature technology for a long time, but I only saw it recently when I was learning and getting in touch with hot fixes. After reading some skinning methods and analyzing and summarizing the source code of the Android-Skin-Loader skinning framework that is more recognized on the market, I once again recorded it to commemorate the time I have passed.

Skin Change Introduction

Skinning is essentially a replacement of resources, including fonts, colors, backgrounds, images, sizes, etc. Of course, we have mature APIs that can be used to control code logic. For example, View changes the background color setBackgroundColor, TextView changes the font setTextSize, etc. But as programmers, how can we tolerate skinning every element of every page line by line of code? We need to use the least code to implement the easiest to maintain and the best (dynamic switching, immediate effect) skinning framework.

Skin changing method 1: switch to theme

Use the same resource ID, but customize different resources under different Themes. We switch the resources used when creating interface elements by actively switching to different Themes. This solution does not require much code, and has an obvious disadvantage that it does not support skinning of already created interfaces, and interface elements must be reloaded. GitHub Demo

Skin changing method 2: Load resource pack

Loading resource packages is a skinning method used by various applications, such as the most commonly used input method skins, browser skins, etc. We can put the skin resource files into the installation package, or download and cache them to the disk. Android applications can use this method to change skins. There is a very high-start skinning framework Android-Skin-Loader on GitHub, which changes the skin of the app by loading resource packages. The analysis of this framework is also the main content of this article.

By comparison, we can find that switching Theme can make a small skinning setting (such as the theme of a custom component), and if we want to switch the theme of the entire app, then loading the resource package is currently the better way.

Android skinning knowledge points

Skinning API

Let's first look at some basic APIs provided by Android. By using these APIs, we can replace resource objects within the App.

 public class Resources{
 public String getString( int id)throws NotFoundException {
        CharSequence res = mAssets.getResourceText(id);
 if (res != null ) {
 return res;
 }
        throw new NotFoundException( "String resource ID #0x"  
                                    + Integer .toHexString(id));
 }
 public Drawable getDrawable( int id)throws NotFoundException {
 /********Part of the code is omitted*******/
 }
 public   int getColor( int id)throws NotFoundException {{
 /********Part of the code is omitted*******/
 }
 /********Part of the code is omitted*******/
 }

This is the api of Resources class that we often use. We can usually use @+id String type defined in resource file, and then generate id (int type) of corresponding resource file in compiled R.java, so as to call these apis provided by Resources through this id (int type) to get the corresponding resource object. This is no problem in the same app, but how can we get this id value in skin package?

 public class Resources{
 /********Part of the code is omitted*******/
 /**
 * Returns a resource identifier given a resource name.
 *@paramname describes the name of the resource
 *@paramdefType resource type
 *@paramdefPackage package name
 *
 *@ return Returns the resource id, 0 indicates that the resource was not found
 */
 public   int getIdentifier(String name , String defType, String defPackage){
 if ( name == null ) {
            throw new NullPointerException( "name is null" );
 }
 try {
 return   Integer .parseInt( name );
        } catch (Exception e) {
 // Ignore  
 }
 return mAssets.getResourceIdentifier( name , defType, defPackage);
 }
 }

Resources provides the ability to use @+id, Type, and PackageName to find out whether there is an id of the corresponding PackageName in the AssetManager whose type and id value can correspond to the parameters, and return it. Then we can use this id to call the Resource API to get the corresponding resource.

One thing we need to pay attention to here is that the mAssets object of the Resources object called by the getIdentifier(String name, String defType, String defPackage) method and the getString(int id) method must be the same and contain the resource package PackageName.

AssetManager Construction

How to construct an AssetManager object instance containing a specific packageName resource?

 public final class AssetManagerimplements AutoCloseable{
 /********Part of the code is omitted*******/
 /**
 * Create a new AssetManager containing only the basic system assets.
 * Applications will not generally use this method, instead retrieving the
 * appropriate asset manager with {@linkResources#getAssets}. Not   for  
 * use by applications.
 * {@hide}
 */
 public AssetManager(){
 synchronized (this) {
 if (DEBUG_REFS) {
 mNumRefs = 0;
                incRefsLocked(this.hashCode());
 }
 init( false );
            if (localLOGV) Log.v(TAG, "New asset manager: " + this);
            ensureSystemAssets();
 }
 }

From the constructor of AssetManager, we can see that there is a {@hide}, so in other classes, the AssetManager instance is created directly. But don't forget that there is also a reflection mechanism in Java that can create class objects.

 AssetManager assetManager = AssetManager.class.newInstance();

How to make the created assetManager contain resource information of a specific PackageName? We can find the corresponding API in AssetManager and call it.

 public final class AssetManagerimplements AutoCloseable{
 /********Part of the code is omitted*******/
 /**
 * Add an additional set   of assets to the asset manager. This can be
 * either a directory or ZIP file. Not   for use by applications. Returns  
 * the cookie of the added asset, or 0 on failure.
 * {@hide}
 */
 public final int addAssetPath(String path){
 synchronized (this) {
 int res = addAssetPathNative(path);
            if (mStringBlocks != null ) {
                makeStringBlocks(mStringBlocks);
 }
 return res;
 }
 }
 }

Similarly, this method does not support external calls, we can only call it through reflection.

 /**
 * apk path
 */
 String apkPath = Environment.getExternalStorageDirectory()+ "/skin.apk" ;
 AssetManager assetManager = null ;
 try {
    AssetManager assetManager = AssetManager.class.newInstance();
    AssetManager.class.getDeclaredMethod( "addAssetPath" , String.class).invoke(assetManager, apkPath);
 } catch (Throwable th) {
 th.printStackTrace();
 }

At this point we can construct our own skinning Resources.

Skinning Resources Structure

 public Resources getSkinResources(Context context){
 /**
 * Plugin apk path
 */
    String apkPath = Environment.getExternalStorageDirectory()+ "/skin.apk" ;
    AssetManager assetManager = null ;
 try {
        AssetManager assetManager = AssetManager.class.newInstance();
        AssetManager.class.getDeclaredMethod( "addAssetPath" , String.class).invoke(assetManager, apkPath);
 } catch (Throwable th) {
 th.printStackTrace();
 }
 return new Resources(assetManager, context.getResources().getDisplayMetrics(), context.getResources().getConfiguration());
 }

Use resource skinning in resource pack

We can combine all the above codes together to achieve the skinning of the app using the resources in the resource package.

 public Resources getSkinResources(Context context){
 /**
 * Plugin apk path
 */
    String apkPath = Environment.getExternalStorageDirectory()+ "/skin.apk" ;
    AssetManager assetManager = null ;
 try {
        AssetManager assetManager = AssetManager.class.newInstance();
        AssetManager.class.getDeclaredMethod( "addAssetPath" , String.class).invoke(assetManager, apkPath);
 } catch (Throwable th) {
 th.printStackTrace();
 }
 return new Resources(assetManager, context.getResources().getDisplayMetrics(), context.getResources().getConfiguration());
 }
 @Override
 protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ImageView imageView = (ImageView) findViewById(R.id.imageView);
    TextView textView = (TextView) findViewById(R.id.text);
 /**
 * Plugin resource object
 */
    Resources resources = getSkinResources(this);
 /**
 * Get image resources
 */
    Drawable drawable = resources.getDrawable(resources.getIdentifier( "night_icon" , "drawable" , "com.tzx.skin" ));
 /**
 * Get text resources
 */
 int color = resources.getColor(resources.getIdentifier( "night_color" , "color" , "com.tzx.skin" )); 
 
    imageView.setImageDrawable(drawable);
 textView.setText(text); 
 
 }

Through the above introduction, we can simply change the skin of the current page. However, if we want to make a mature skinning framework, then this alone is not enough. Let's improve our thinking level. If we directly use the resource files in the skin resource package when creating the View, then this will undoubtedly make the skinning easier to maintain.

LayoutInflater.Factory

If you have read my previous article about LayoutInflater&Factory, you can skip this part.

Fortunately, Android provides us with a way to make modifications when View is produced.

 public abstract class LayoutInflater{
 /***Part of the code is omitted****/
 public interface Factory {
 public   View onCreateView(String name , Context context, AttributeSet attrs);
 } 
 
 public interface Factory2extends Factory{
 public   View onCreateView( View parent, String name , Context context, AttributeSet attrs);
 }
 /***Part of the code is omitted****/
 }

We can set the Factory for the Window object of the current page when creating it, so when the View in the Window is created, it will be created first through the Factory that we set. For the usage of Factory and related precautions, please move to Meet LayoutInflater&Factory, which contains all the relevant knowledge points about Factory.

Android-Skin-Loader Analysis

initialization

Initialize the skinning framework and import the resource package that needs to be skinned (currently an apk file containing only resource files).

 public class SkinApplicationextends Application{
 public void onCreate(){
 super.onCreate();
 initSkinLoader();
 }
 /**
 * Must call init first  
 */
    private void initSkinLoader(){
        SkinManager.getInstance().init(this);
        SkinManager.getInstance(). load ();
 }
 }

Constructing a skinning object

Import the resource package that needs to be skinned and construct a skinned Resources instance.

 /**
 * Load resources from apk in asyc task
 *@paramskinPackagePath path of skin apk
 *@paramcallback callback to notify user  
 */
 public void load (String skinPackagePath,final ILoaderListener callback){ 
     
    new AsyncTask<String, Void, Resources>() { 
 
        protected void onPreExecute(){
            if (callback != null ) {
                callback.onStart();
 }
 }; 
 
 @Override
        protected Resources doInBackground(String... params){
 try {
                if (params. length == 1) {
                    String skinPkgPath = params[0]; 
                     
                    File file = new File(skinPkgPath);
                    if(file == null || !file.exists()){
 return   null ;
 } 
                     
                    PackageManager mPm = context.getPackageManager();
 // Retrieve an installation package file outside the program
                    PackageInfo mInfo = mPm.getPackageArchiveInfo(skinPkgPath, PackageManager.GET_ACTIVITIES);
 //Get the installation package registration
                    skinPackageName = mInfo.packageName;
 //Build a skin-changing AssetManager instance
                    AssetManager assetManager = AssetManager.class.newInstance();
                    Method addAssetPath = assetManager.getClass().getMethod( "addAssetPath" , String.class);
                    addAssetPath.invoke(assetManager, skinPkgPath);
 //Build a skinning Resources instance
                    Resources superRes = context.getResources();
                    Resources skinResource = new Resources(assetManager,superRes.getDisplayMetrics(),superRes.getConfiguration());
 //Store the current skin path
                    SkinConfig.saveSkinPath(context, skinPkgPath); 
                     
                    skinPath = skinPkgPath;
                    isDefaultSkin = false ;
 return skinResource;
 }
 return   null ;
            } catch (Exception e) {
                e.printStackTrace();
 return   null ;
 }
 }; 
 
        protected void onPostExecute(Resources result){
            mResources = result; 
 
            if (mResources != null ) {
                if (callback != null ) callback.onSuccess();
 //Update the skinnable interface
                notifySkinUpdate();
 } else {
                isDefaultSkin = true ;
                if (callback != null ) callback.onFailed();
 }
 }; 
 
    } .execute (skinPackagePath);
 }

Defining the base class

The common code of the base class of the skinning page implements the basic skinning function.

 public class BaseFragmentActivityextends FragmentActivityimplements ISkinUpdate,IDynamicNewView{ 
     
 /***Part of the code is omitted****/ 
     
 //Customize LayoutInflater.Factory
    private SkinInflaterFactory mSkinInflaterFactory; 
     
 @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState); 
     
 try {
 //Set LayoutInflater's mFactorySet to true , indicating that mFactory has not been set, otherwise an exception will be thrown.
            Field field = LayoutInflater.class.getDeclaredField( "mFactorySet" );
            field.setAccessible( true );
            field.setBoolean(getLayoutInflater(), false );
 //Set LayoutInflater's MFactory
            mSkinInflaterFactory = new SkinInflaterFactory();
            getLayoutInflater().setFactory(mSkinInflaterFactory); 
 
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
 } 
         
 } 
 
 @Override
    protected void onResume(){
 super.onResume();
 //Register skin management object
        SkinManager.getInstance().attach(this);
 } 
     
 @Override
    protected void onDestroy(){
 super.onDestroy();
 //Unregister skin management object
        SkinManager.getInstance().detach(this);
 }
 /***Part of the code is omitted****/
 }

SkinInflaterFactory

• SkinInflaterFactory creates a View and changes the skin of the View.

Constructing a View

 public class SkinInflaterFactoryimplements Factory{
 /***Part of the code is omitted****/
 public   View onCreateView(String name , Context context, AttributeSet attrs){
 //Read the skin:enable property of View , false means no skin change is required
 // if this is   NOT enable to be skinned, simply skip it
        boolean isSkinEnable = attrs.getAttributeBooleanValue(SkinConfig.NAMESPACE, SkinConfig.ATTR_SKIN_ENABLE, false );
 if (!isSkinEnable){
 return   null ;
 }
 //Create View  
 View   view = createView(context, name , attrs);
 if ( view == null ) {
 return   null ;
 }
 //If the View is created successfully, reskin the View
        parseSkinAttr(context, attrs, view );
 return   view ;
 }
 //Create a View . For an analogy, see the createViewFromTag method of LayoutInflater.
    private View createView(Context context, String name , AttributeSet attrs){
 View   view = null ;
 try {
            if (-1 == name .indexOf( '.' )){
                if ( "View" .equals( name )) {
 view = LayoutInflater. from (context).createView( name , "android.view." , attrs);
 }
                if ( view == null ) {
 view = LayoutInflater. from (context).createView( name , "android.widget." , attrs);
 }
                if ( view == null ) {
 view = LayoutInflater. from (context).createView( name , "android.webkit." , attrs);
 }
 } else {
 view = LayoutInflater. from (context).createView( name , null , attrs);
 } 
 
            Li( "about to create " + name ); 
 
        } catch (Exception e) {
            Le( "error while create 【" + name + "】 : " + e.getMessage());
 view = null ;
 }
 return   view ;
 }
 }

Skinning the produced View

 public class SkinInflaterFactoryimplements Factory{
 //Store the View that needs to be skinned in the current Activity  
    private List<SkinItem> mSkinItems = new ArrayList<SkinItem>();
 /***Part of the code is omitted****/
    private void parseSkinAttr(Context context, AttributeSet attrs, View   view ){
 // All attribute tags of the current View
        List<SkinAttr> viewAttrs = new ArrayList<SkinAttr>(); 
         
 for ( int i = 0; i < attrs.getAttributeCount(); i++){
            String attrName = attrs.getAttributeName(i);
            String attrValue = attrs.getAttributeValue(i); 
             
            if(!AttrFactory.isSupportedAttr(attrName)){
 continue ;
 }
 //Filter the value of the attribute in the view attribute tag to be a reference type
            if(attrValue.startsWith( "@" )){
 try {
 int id = Integer .parseInt ( attrValue.substring (1));
                    String entryName = context.getResources().getResourceEntryName(id);
                    String typeName = context.getResources().getResourceTypeName(id);
 //Construct SkinAttr instance, attrname, id, entryName, typeName
 //The name of the attribute (background), the id value of the attribute ( int type), the id value of the attribute (@+id, string type), the value type of the attribute (color)
                    SkinAttr mSkinAttr = AttrFactory.get(attrName, id, entryName, typeName);
                    if (mSkinAttr != null ) {
                        viewAttrs.add (mSkinAttr) ;
 }
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                } catch (NotFoundException e) {
                    e.printStackTrace();
 }
 }
 }
 //If the current View needs to be skinned, add it to mSkinItems
        if(!ListUtils.isEmpty(viewAttrs)){
            SkinItem skinItem = new SkinItem();
            skinItem.view = view ;
            skinItem.attrs = viewAttrs; 
 
            mSkinItems.add (skinItem);
 //Whether to use external skin for skinning
            if(SkinManager.getInstance().isExternalSkin()){
                skinItem.apply();
 }
 }
 }
 }

Resource Acquisition

Find the corresponding resource name through the current resource id, and then find the resource id corresponding to the resource name in the skin package.

 public class SkinManagerimplements ISkinLoader{
 /***Part of the code is omitted****/
 public   int getColor( int resId){
 int originColor = context.getResources().getColor(resId);
 //Whether the skin is not downloaded or the default skin is currently used
        if(mResources == null || isDefaultSkin){
 return originColor;
 }
 //According to the resId value, get the corresponding xml @+id String type value
        String resName = context.getResources().getResourceEntryName(resId);
 //Get the corresponding resId in mResources of the skin package according to resName
 int trueResId = mResources.getIdentifier(resName, "color" , skinPackageName);
 int trueColor = 0;
 try{
 //Get the corresponding resource value according to resId
            trueColor = mResources.getColor(trueResId);
        }catch(NotFoundException e){
            e.printStackTrace();
            trueColor = originColor;
 } 
         
 return trueColor;
 }
 public Drawable getDrawable( int resId){...}
 }

other

In addition, the following skin management APIs are added (download, listen for callbacks, apply, cancel, exception handling, extension modules, etc.).

Summarize

Changing skin is so simple~!~!

The article ends here. If you have anything else to communicate, please leave a message~!~!