Resource.arsc文件格式解析

最新推荐文章于 2024-01-10 16:17:31 发布
最新推荐文章于 2024-01-10 16:17:31 发布
阅读量2.5k 收藏 1
点赞数


Resource.arsc文件格式

借用了互联网一些资料，记录在此。

准备工作

我们在使用apktool工具进行反编译的时候，会发现有一个：res/values/public.xml这个文件：


我们查看一下public.xml文件内容：


看到了，这个文件就保存了apk中所有的类型和对应的id值，我们看到这里面的每个条目内容都是：

type：类型名

name：资源名

id：资源的id

类型的话有这么几种：

drawable，menu，layout，string，attr，color，style等

所以我们会在反编译之后的文件夹中看到这几个类型的文件xml内容。


上面我们介绍了如何使用apktool反编译之后的内容，下面我们要做的事情就是如何来解析resource.arsc文件，解析出这些文件。

我们解压一个apk得到对应的resource.arsc文件。按照国际惯例，每个文件的格式描述都是有对应的数据结构的，resource也不例外：frameworks\base\include\androidfw\ResourceTypes.h，这就是resource中定义的所有数据结构。

下面再来看一张神图：


每次我们在解析文件的时候都会有一张神图，我们按照这张图来进行数据解析工作。


三、数据结构定义


这个是项目工程结构，我们看到定义了很多的数据结构

第一、头部信息

Resources.arsc文件格式是由一系列的chunk构成,每一个chunk均包含如下结构的ResChunk_header,用来描述这个chunk的基本信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.Utils;  
  4.   
  5. /** 
  6. struct ResChunk_header 
  7. { 
  8.     // Type identifier for this chunk.  The meaning of this value depends 
  9.     // on the containing chunk. 
  10.     uint16_t type; 
  11.  
  12.     // Size of the chunk header (in bytes).  Adding this value to 
  13.     // the address of the chunk allows you to find its associated data 
  14.     // (if any). 
  15.     uint16_t headerSize; 
  16.  
  17.     // Total size of this chunk (in bytes).  This is the chunkSize plus 
  18.     // the size of any data associated with the chunk.  Adding this value 
  19.     // to the chunk allows you to completely skip its contents (including 
  20.     // any child chunks).  If this value is the same as chunkSize, there is 
  21.     // no data associated with the chunk. 
  22.     uint32_t size; 
  23. }; 
  24.  * @author i 
  25.  * 
  26.  */  
  27. public class ResChunkHeader {  
  28.       
  29.     public short type;  
  30.     public short headerSize;  
  31.     public int size;  
  32.       
  33.     public int getHeaderSize(){  
  34.         return 2+2+4;  
  35.     }  
  36.       
  37.     @Override  
  38.     public String toString(){  
  39.         return "type:"+Utils.bytesToHexString(Utils.int2Byte(type))+",headerSize:"+headerSize+",size:"+size;  
  40.     }  
  41.   
  42. }  
type：是当前这个chunk的类型

headerSize：是当前这个chunk的头部大小

size：是当前这个chunk的大小


第二、资源索引表的头部信息

Resources.arsc文件的第一个结构是资源索引表头部。其结构如下,描述了Resources.arsc文件的大小和资源包数量。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_header 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // The number of ResTable_package structures. 
  9.     uint32_t packageCount; 
  10. }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableHeader {  
  15.   
  16.     public ResChunkHeader header;  
  17.     public int packageCount;  
  18.       
  19.     public ResTableHeader(){  
  20.         header = new ResChunkHeader();  
  21.     }  
  22.       
  23.     public int getHeaderSize(){  
  24.         return header.getHeaderSize() + 4;  
  25.     }  
  26.       
  27.     @Override  
  28.     public String toString(){  
  29.         return "header:"+header.toString()+"\n" + "packageCount:"+packageCount;  
  30.     }  
  31.       
  32. }  

header：就是标准的Chunk头部信息格式

packageCount：被编译的资源包的个数

Android中一个apk可能包含多个资源包，默认情况下都只有一个就是应用的包名所在的资源包

实例：

图中蓝色高亮的部分就是资源索引表头部。通过解析,我们可以得到如下信息,这个chunk的类型为RES_TABLE_TYPE,头部大小为0XC,整个chunk的大小为1400252byte,有一个编译好的资源包。



第三、资源项的值字符串资源池

紧跟着资源索引表头部的是资源项的值字符串资源池,这个字符串资源池包含了所有的在资源包里面所定义的资源项的值字符串,字符串资源池头部的结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResStringPool_header 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // Number of strings in this pool (number of uint32_t indices that follow 
  9.     // in the data). 
  10.     uint32_t stringCount; 
  11.  
  12.     // Number of style span arrays in the pool (number of uint32_t indices 
  13.     // follow the string indices). 
  14.     uint32_t styleCount; 
  15.  
  16.     // Flags. 
  17.     enum { 
  18.         // If set, the string index is sorted by the string values (based 
  19.         // on strcmp16()). 
  20.         SORTED_FLAG = 1<<0, 
  21.  
  22.         // String pool is encoded in UTF-8 
  23.         UTF8_FLAG = 1<<8 
  24.     }; 
  25.     uint32_t flags; 
  26.  
  27.     // Index from header of the string data. 
  28.     uint32_t stringsStart; 
  29.  
  30.     // Index from header of the style data. 
  31.     uint32_t stylesStart; 
  32. }; 
  33.  * @author i 
  34.  * 
  35.  */  
  36. public class ResStringPoolHeader {  
  37.       
  38.     public ResChunkHeader header;  
  39.     public int stringCount;  
  40.     public int styleCount;  
  41.       
  42.     public final static int SORTED_FLAG = 1;  
  43.     public final static int UTF8_FLAG = (1<<8);  
  44.       
  45.     public int flags;  
  46.     public int stringsStart;  
  47.     public int stylesStart;  
  48.       
  49.     public ResStringPoolHeader(){  
  50.         header = new ResChunkHeader();  
  51.     }  
  52.       
  53.     public int getHeaderSize(){  
  54.         return header.getHeaderSize() + 4 + 4 + 4 + 4 + 4;  
  55.     }  
  56.       
  57.     @Override  
  58.     public String toString(){  
  59.         return "header:"+header.toString()+"\n" + "stringCount:"+stringCount+",styleCount:"+styleCount+",flags:"+flags+",stringStart:"+stringsStart+",stylesStart:"+stylesStart;  
  60.     }  
  61.       
  62. }  

header：标准的Chunk头部信息结构

stringCount：字符串的个数

styleCount：字符串样式的个数

flags：字符串的属性,可取值包括0x000(UTF-16),0x001(字符串经过排序)、0X100(UTF-8)和他们的组合值

stringStart：字符串内容块相对于其头部的距离

stylesStart：字符串样式块相对于其头部的距离

实例：


图中绿色高亮的部分就是字符串资源池头部,通过解析,我们可以得到如下信息,这个chunk的类型为RES_STRING_POOL_TYPE,即字符串资源池。头部大小为0X1C,整个chunk的大小为369524byte,有8073条字符串,72个字符串样式,为UTF-8编码,无排序,字符串内容块相对于此chunk头部的偏移为0X7F60,字符串样式块相对于此chunk头部的偏移为0X5A054。
紧接着头部的的是两个偏移数组，分别是字符串偏移数组和字符串样式偏移数组。这两个偏移数组的大小分别等于stringCount和styleCount的值，而每一个元素的类型都是无符号整型。整个字符中资源池结构如下。


字符串资源池中的字符串前两个字节为字符串长度,长度计算方法如下。另外如果字符串编码格式为UTF-8则字符串以0X00作为结束符,UTF-16则以0X0000作为结束符。
len = (((hbyte & 0x7F) << 8)) | lbyte;
字符串与字符串样式有一一对应的关系,也就是说如果第n个字符串有样式,则它的样式描述位于样式块的第n个元素。 字符串样式的结构包括如下两个结构体,ResStringPool_ref和ResStringPool_span。 一个字符串可以对应多个ResStringPool_span和一个ResStringPool_ref。ResStringPool_span在前描述字符串的样式,ResStringPool_ref在后固定值为0XFFFFFFFF作为占位符。样式块最后会以两个值为0XFFFFFFFF的ResStringPool_ref作为结束。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResStringPool_ref 
  5.  { 
  6.      uint32_t index; 
  7.  }; 
  8.   
  9.  * @author i 
  10.  * 
  11.  */  
  12. public class ResStringPoolRef {  
  13.   
  14.     public int index;  
  15.       
  16.     public int getSize(){  
  17.         return 4;  
  18.     }  
  19.       
  20.     @Override  
  21.     public String toString(){  
  22.         return "index:"+index;  
  23.     }  
  24.       
  25. }  

实例：


图中蓝色高亮的部分就是样式内容块,按照格式解析可以得出,第一个字符串和第二字符串无样式,第三个字符串第4个字符到第7个字符的位置样式为字符串资源池中0X1F88的字符,以此类推。


第四、Package数据块

接着资源项的值字符串资源池后面的部分就是Package数据块,这个数据块记录编译包的元数据,头部结构如下：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_package 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // If this is a base package, its ID.  Package IDs start 
  9.     // at 1 (corresponding to the value of the package bits in a 
  10.     // resource identifier).  0 means this is not a base package. 
  11.     uint32_t id; 
  12.  
  13.     // Actual name of this package, \0-terminated. 
  14.     char16_t name[128]; 
  15.  
  16.     // Offset to a ResStringPool_header defining the resource 
  17.     // type symbol table.  If zero, this package is inheriting from 
  18.     // another base package (overriding specific values in it). 
  19.     uint32_t typeStrings; 
  20.  
  21.     // Last index into typeStrings that is for public use by others. 
  22.     uint32_t lastPublicType; 
  23.  
  24.     // Offset to a ResStringPool_header defining the resource 
  25.     // key symbol table.  If zero, this package is inheriting from 
  26.     // another base package (overriding specific values in it). 
  27.     uint32_t keyStrings; 
  28.  
  29.     // Last index into keyStrings that is for public use by others. 
  30.     uint32_t lastPublicKey; 
  31. }; 
  32.  * @author i 
  33.  * 
  34.  */  
  35. public class ResTablePackage {  
  36.       
  37.     public ResChunkHeader header;  
  38.     public int id;  
  39.     public char[] name = new char[128];  
  40.     public int typeStrings;  
  41.     public int lastPublicType;  
  42.     public int keyStrings;  
  43.     public int lastPublicKey;  
  44.       
  45.     public ResTablePackage(){  
  46.         header = new ResChunkHeader();  
  47.     }  
  48.       
  49.     @Override  
  50.     public String toString(){  
  51.         return "header:"+header.toString()+"\n"+",id="+id+",name:"+name.toString()+",typeStrings:"+typeStrings+",lastPublicType:"+lastPublicType+",keyStrings:"+keyStrings+",lastPublicKey:"+lastPublicKey;  
  52.     }  
  53.   
  54. }  
header：Chunk的头部信息数据结构

id：包的ID,等于Package Id,一般用户包的值Package Id为0X7F,系统资源包的Package Id为0X01；这个值很重要的，在后面我们构建前面说到的那个public.xml中的id值的时候需要用到。

name：包名

typeString：类型字符串资源池相对头部的偏移

lastPublicType：最后一个导出的Public类型字符串在类型字符串资源池中的索引，目前这个值设置为类型字符串资源池的元素个数。在解析的过程中没发现他的用途

keyStrings：资源项名称字符串相对头部的偏移

lastPublicKey：最后一个导出的Public资源项名称字符串在资源项名称字符串资源池中的索引，目前这个值设置为资源项名称字符串资源池的元素个数。在解析的过程中没发现他的用途


实例：


图中紫色高亮的部分就是ResTable_package,按照上面的格式解析数据,我们可以得出,此Chunk的Type为RES_TABLE_PACKAGE_TYPE,头部大小为0X120,整个chunk的大小为1030716byte,Package Id为0X7F,包名称为co.runner.app,类型字符串资源池距离头部的偏移是0X120,有15条字符串,资源项名称字符串资源池0X1EC,有6249条字符串。
Packege数据块的整体结构,可以用以下的示意图表示：


其中Type String Pool和Key String Pool是两个字符串资源池,结构和资源项的值字符串资源池结构相同,分别对应类型字符串资源池和资源项名称字符串资源池。
再接下来的结构体可能是类型规范数据块或者类型资源项数据块,我们可以通过他们的Type来识别,类型规范数据块的Type为RES_TABLE_TYPE_SPEC_TYPE,类型资源项数据块的Type为RES_TABLE_TYPE_TYPE。


第五、类型规范数据块

类型规范数据块用来描述资源项的配置差异性。通过这个差异性描述，我们就可以知道每一个资源项的配置状况。知道了一个资源项的配置状况之后，Android资源管理框架在检测到设备的配置信息发生变化之后，就可以知道是否需要重新加载该资源项。类型规范数据块是按照类型来组织的，也就是说，每一种类型都对应有一个类型规范数据块。其数据块头部结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_typeSpec 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // The type identifier this chunk is holding.  Type IDs start 
  9.     // at 1 (corresponding to the value of the type bits in a 
  10.     // resource identifier).  0 is invalid. 
  11.     uint8_t id; 
  12.      
  13.     // Must be 0. 
  14.     uint8_t res0; 
  15.     // Must be 0. 
  16.     uint16_t res1; 
  17.      
  18.     // Number of uint32_t entry configuration masks that follow. 
  19.     uint32_t entryCount; 
  20.  
  21.     enum { 
  22.         // Additional flag indicating an entry is public. 
  23.         SPEC_PUBLIC = 0x40000000 
  24.     }; 
  25. }; 
  26.  * @author i 
  27.  * 
  28.  */  
  29. public class ResTableTypeSpec {  
  30.       
  31.     public final static int SPEC_PUBLIC = 0x40000000;  
  32.       
  33.     public ResChunkHeader header;  
  34.     public byte id;  
  35.     public byte res0;  
  36.     public short res1;  
  37.     public int entryCount;  
  38.       
  39.     public ResTableTypeSpec(){  
  40.         header = new ResChunkHeader();  
  41.     }  
  42.       
  43.     @Override  
  44.     public String toString(){  
  45.         return "header:"+header.toString()+",id:"+id+",res0:"+res0+",res1:"+res1+",entryCount:"+entryCount;  
  46.     }  
  47.       
  48. }  
header：Chunk的头部信息结构

id：标识资源的Type ID,Type ID是指资源的类型ID。资源的类型有animator、anim、color、drawable、layout、menu、raw、string和xml等等若干种，每一种都会被赋予一个ID。

res0：保留,始终为0

res1：保留,始终为0

entryCount：等于本类型的资源项个数,指名称相同的资源项的个数。


实例：


图中绿色高亮的部分就是ResTable_typeSpec,按照上面的格式解析数据,我们可以得出,此Chunk的Type为RES_TABLE_TYPE_SPEC_TYPE,头部大小为0X10,整个chunk的大小为564byte,资源ID为1,本类型资源项数量为137。
ResTable_typeSpec后面紧跟着的是一个大小为entryCount的uint32_t数组，每一个数组元素都用来描述一个资源项的配置差异性的。


第六、资源类型项数据块

类型资源项数据块用来描述资源项的具体信息, 这样我们就可以知道每一个资源项的名称、值和配置等信息。 类型资源项数据同样是按照类型和配置来组织的,也就是说,一个具有n个配置的类型一共对应有n个类型资源项数据块。其数据块头部结构如下

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_type 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     enum { 
  9.         NO_ENTRY = 0xFFFFFFFF 
  10.     }; 
  11.      
  12.     // The type identifier this chunk is holding.  Type IDs start 
  13.     // at 1 (corresponding to the value of the type bits in a 
  14.     // resource identifier).  0 is invalid. 
  15.     uint8_t id; 
  16.      
  17.     // Must be 0. 
  18.     uint8_t res0; 
  19.     // Must be 0. 
  20.     uint16_t res1; 
  21.      
  22.     // Number of uint32_t entry indices that follow. 
  23.     uint32_t entryCount; 
  24.  
  25.     // Offset from header where ResTable_entry data starts. 
  26.     uint32_t entriesStart; 
  27.      
  28.     // Configuration this collection of entries is designed for. 
  29.     ResTable_config config; 
  30. }; 
  31.  * @author i 
  32.  * 
  33.  */  
  34. public class ResTableType {  
  35.       
  36.     public ResChunkHeader header;  
  37.       
  38.     public final static int NO_ENTRY = 0xFFFFFFFF;  
  39.       
  40.     public byte id;  
  41.     public byte res0;  
  42.     public short res1;  
  43.     public int entryCount;  
  44.     public int entriesStart;  
  45.       
  46.     public ResTableConfig resConfig;  
  47.       
  48.     public ResTableType(){  
  49.         header = new ResChunkHeader();  
  50.         resConfig = new ResTableConfig();  
  51.     }  
  52.   
  53.     public int getSize(){  
  54.         return header.getHeaderSize() + 1 + 1 + 2 + 4 + 4;  
  55.     }  
  56.       
  57.     @Override  
  58.     public String toString(){  
  59.         return "header:"+header.toString()+",id:"+id+",res0:"+res0+",res1:"+res1+",entryCount:"+entryCount+",entriesStart:"+entriesStart;  
  60.     }  
  61.   
  62. }  
header：Chunk的头部信息结构

id：标识资源的Type ID

res0：保留,始终为0

res1：保留,始终为0

entryCount：等于本类型的资源项个数,指名称相同的资源项的个数。

entriesStart：等于资源项数据块相对头部的偏移值。

resConfig：指向一个ResTable_config,用来描述配置信息,地区,语言,分辨率等

实例：


图中红色高亮的部分就是ResTable_type,按照上面的格式解析数据,我们可以得出,RES_TABLE_TYPE_TYPE,头部大小为0X44,整个chunk的大小为4086byte,资源ID为1,本类型资源项数量为137,资源数据块相对于头部的偏移为0X268。
ResTable_type后接着是一个大小为entryCount的uint32_t数组，每一个数组元素都用来描述一个资源项数据块的偏移位置。 紧跟在这个偏移数组后面的是一个大小为entryCount的ResTable_entry数组,每一个数组元素都用来描述一个资源项的具体信息。ResTable_entry的结构如下：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.ParseResourceUtils;  
  4.   
  5. /** 
  6. struct ResTable_entry 
  7. { 
  8.     // Number of bytes in this structure. 
  9.     uint16_t size; 
  10.  
  11.     enum { 
  12.         // If set, this is a complex entry, holding a set of name/value 
  13.         // mappings.  It is followed by an array of ResTable_map structures. 
  14.         FLAG_COMPLEX = 0x0001, 
  15.         // If set, this resource has been declared public, so libraries 
  16.         // are allowed to reference it. 
  17.         FLAG_PUBLIC = 0x0002 
  18.     }; 
  19.     uint16_t flags; 
  20.      
  21.     // Reference into ResTable_package::keyStrings identifying this entry. 
  22.     struct ResStringPool_ref key; 
  23. }; 
  24.  * @author i 
  25.  * 
  26.  */  
  27. public class ResTableEntry {  
  28.       
  29.     public final static int FLAG_COMPLEX = 0x0001;  
  30.     public final static int FLAG_PUBLIC = 0x0002;  
  31.       
  32.     public short size;  
  33.     public short flags;  
  34.       
  35.     public ResStringPoolRef key;  
  36.       
  37.     public ResTableEntry(){  
  38.         key = new ResStringPoolRef();  
  39.     }  
  40.       
  41.     public int getSize(){  
  42.         return 2+2+key.getSize();  
  43.     }  
  44.       
  45.     @Override  
  46.     public String toString(){  
  47.         return "size:"+size+",flags:"+flags+",key:"+key.toString()+",str:"+ParseResourceUtils.getKeyString(key.index);  
  48.     }  
  49.   
  50. }  
ResTable_entry根据flags的不同,后面跟随的数据也不相同,如果flags此位为1,则ResTable_entry是ResTable_map_entry,ResTable_map_entry继承自ResTable_entry,其结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResTable_map_entry : public ResTable_entry 
  5.  { 
  6.      //指向父ResTable_map_entry的资源ID，如果没有父ResTable_map_entry，则等于0。 
  7.      ResTable_ref parent; 
  8.      //等于后面ResTable_map的数量 
  9.      uint32_t count; 
  10.  }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableMapEntry extends ResTableEntry{  
  15.       
  16.     public ResTableRef parent;  
  17.     public int count;  
  18.       
  19.     public ResTableMapEntry(){  
  20.         parent = new ResTableRef();  
  21.     }  
  22.       
  23.     @Override  
  24.     public int getSize(){  
  25.         return super.getSize() + parent.getSize() + 4;  
  26.     }  
  27.       
  28.     @Override  
  29.     public String toString(){  
  30.         return super.toString() + ",parent:"+parent.toString()+",count:"+count;  
  31.     }  
  32.   
  33. }  
ResTable_map_entry其后跟随则count个ResTable_map类型的数组,ResTable_map的结构如下：
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResTable_map 
  5.  { 
  6.      //bag资源项ID 
  7.      ResTable_ref name; 
  8.      //bag资源项值 
  9.      Res_value value; 
  10.  }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableMap {  
  15.       
  16.     public ResTableRef name;  
  17.     public ResValue value;  
  18.       
  19.     public ResTableMap(){  
  20.         name = new ResTableRef();  
  21.         value = new ResValue();  
  22.     }  
  23.       
  24.     public int getSize(){  
  25.         return name.getSize() + value.getSize();  
  26.     }  
  27.       
  28.     @Override  
  29.     public String toString(){  
  30.         return name.toString()+",value:"+value.toString();  
  31.     }  
  32.   
  33. }  

实例：


图中颜色由深到浅就是一个完整的flags为1的资源项,现在就一起来解读这段数据的含义,这个资源项头部的大小为0X10,flags为1所以后面跟随的是ResTable_map数组,名称没有在资源项引用池中,没有父map_entry,有一个ResTable_map。
如果flags此位为0,则ResTable_entry其后跟随的是一个Res_value,描述一个普通资源的值,Res_value结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.ParseResourceUtils;  
  4.   
  5. /** 
  6. struct Res_value 
  7.  { 
  8.      //Res_value头部大小 
  9.      uint16_t size; 
  10.      //保留,始终为0 
  11.      uint8_t res0; 
  12.   
  13.      enum { 
  14.          TYPE_NULL = 0x00, 
  15.          TYPE_REFERENCE = 0x01, 
  16.          TYPE_ATTRIBUTE = 0x02, 
  17.          TYPE_STRING = 0x03, 
  18.          TYPE_FLOAT = 0x04, 
  19.          TYPE_DIMENSION = 0x05, 
  20.          TYPE_FRACTION = 0x06, 
  21.          TYPE_FIRST_INT = 0x10, 
  22.          TYPE_INT_DEC = 0x10, 
  23.          TYPE_INT_HEX = 0x11, 
  24.          TYPE_INT_BOOLEAN = 0x12, 
  25.          TYPE_FIRST_COLOR_INT = 0x1c, 
  26.          TYPE_INT_COLOR_ARGB8 = 0x1c, 
  27.          TYPE_INT_COLOR_ARGB8 = 0x1c, 
  28.          TYPE_INT_COLOR_RGB8 = 0x1d, 
  29.          TYPE_INT_COLOR_ARGB4 = 0x1e, 
  30.          TYPE_INT_COLOR_RGB4 = 0x1f, 
  31.          TYPE_LAST_COLOR_INT = 0x1f, 
  32.          TYPE_LAST_INT = 0x1f 
  33.      }; 
  34.      //数据的类型,可以从上面的枚举类型中获取 
  35.      uint8_t dataType; 
  36.   
  37.      //数据对应的索引 
  38.      uint32_t data; 
  39.  }; 
  40.  * @author i 
  41.  * 
  42.  */  
  43. public class ResValue {  
  44.       
  45.     //dataType字段使用的常量  
  46.     public final static int TYPE_NULL = 0x00;  
  47.     public final static int TYPE_REFERENCE = 0x01;  
  48.     public final static int TYPE_ATTRIBUTE = 0x02;  
  49.     public final static int TYPE_STRING = 0x03;  
  50.     public final static int TYPE_FLOAT = 0x04;  
  51.     public final static int TYPE_DIMENSION = 0x05;  
  52.     public final static int TYPE_FRACTION = 0x06;  
  53.     public final static int TYPE_FIRST_INT = 0x10;  
  54.     public final static int TYPE_INT_DEC = 0x10;  
  55.     public final static int TYPE_INT_HEX = 0x11;  
  56.     public final static int TYPE_INT_BOOLEAN = 0x12;  
  57.     public final static int TYPE_FIRST_COLOR_INT = 0x1c;  
  58.     public final static int TYPE_INT_COLOR_ARGB8 = 0x1c;  
  59.     public final static int TYPE_INT_COLOR_RGB8 = 0x1d;  
  60.     public final static int TYPE_INT_COLOR_ARGB4 = 0x1e;  
  61.     public final static int TYPE_INT_COLOR_RGB4 = 0x1f;  
  62.     public final static int TYPE_LAST_COLOR_INT = 0x1f;  
  63.     public final static int TYPE_LAST_INT = 0x1f;  
  64.       
  65.     public static final int  
  66.     COMPLEX_UNIT_PX         =0,  
  67.     COMPLEX_UNIT_DIP        =1,  
  68.     COMPLEX_UNIT_SP         =2,  
  69.     COMPLEX_UNIT_PT         =3,  
  70.     COMPLEX_UNIT_IN         =4,  
  71.     COMPLEX_UNIT_MM         =5,  
  72.     COMPLEX_UNIT_SHIFT      =0,  
  73.     COMPLEX_UNIT_MASK       =15,  
  74.     COMPLEX_UNIT_FRACTION   =0,  
  75.     COMPLEX_UNIT_FRACTION_PARENT=1,  
  76.     COMPLEX_RADIX_23p0      =0,  
  77.     COMPLEX_RADIX_16p7      =1,  
  78.     COMPLEX_RADIX_8p15      =2,  
  79.     COMPLEX_RADIX_0p23      =3,  
  80.     COMPLEX_RADIX_SHIFT     =4,  
  81.     COMPLEX_RADIX_MASK      =3,  
  82.     COMPLEX_MANTISSA_SHIFT  =8,  
  83.     COMPLEX_MANTISSA_MASK   =0xFFFFFF;  
  84.       
  85.       
  86.     public short size;  
  87.     public byte res0;  
  88.     public byte dataType;  
  89.     public int data;  
  90.       
  91.     public int getSize(){  
  92.         return 2 + 1 + 1 + 4;  
  93.     }  
  94.       
  95.     public String getTypeStr(){  
  96.         switch(dataType){  
  97.             case TYPE_NULL:  
  98.                 return "TYPE_NULL";  
  99.             case TYPE_REFERENCE:  
  100.                 return "TYPE_REFERENCE";  
  101.             case TYPE_ATTRIBUTE:  
  102.                 return "TYPE_ATTRIBUTE";  
  103.             case TYPE_STRING:  
  104.                 return "TYPE_STRING";  
  105.             case TYPE_FLOAT:  
  106.                 return "TYPE_FLOAT";  
  107.             case TYPE_DIMENSION:  
  108.                 return "TYPE_DIMENSION";  
  109.             case TYPE_FRACTION:  
  110.                 return "TYPE_FRACTION";  
  111.             case TYPE_FIRST_INT:  
  112.                 return "TYPE_FIRST_INT";  
  113.             case TYPE_INT_HEX:  
  114.                 return "TYPE_INT_HEX";  
  115.             case TYPE_INT_BOOLEAN:  
  116.                 return "TYPE_INT_BOOLEAN";  
  117.             case TYPE_FIRST_COLOR_INT:  
  118.                 return "TYPE_FIRST_COLOR_INT";  
  119.             case TYPE_INT_COLOR_RGB8:  
  120.                 return "TYPE_INT_COLOR_RGB8";  
  121.             case TYPE_INT_COLOR_ARGB4:  
  122.                 return "TYPE_INT_COLOR_ARGB4";  
  123.             case TYPE_INT_COLOR_RGB4:  
  124.                 return "TYPE_INT_COLOR_RGB4";  
  125.         }  
  126.         return "";  
  127.     }  
  128.       
  129.     /*public String getDataStr(){ 
  130.         if(dataType == TYPE_STRING){ 
  131.             return ParseResourceUtils.getResString(data); 
  132.         }else if(dataType == TYPE_FIRST_COLOR_INT){ 
  133.             return Utils.bytesToHexString(Utils.int2Byte(data)); 
  134.         }else if(dataType == TYPE_INT_BOOLEAN){ 
  135.             return data==0 ? "false" : "true"; 
  136.         } 
  137.         return data+""; 
  138.     }*/  
  139.       
  140.     public String getDataStr() {  
  141.         if (dataType == TYPE_STRING) {  
  142.             return ParseResourceUtils.getResString(data);  
  143.         }  
  144.         if (dataType == TYPE_ATTRIBUTE) {  
  145.             return String.format("?%s%08X",getPackage(data),data);  
  146.         }  
  147.         if (dataType == TYPE_REFERENCE) {  
  148.             return String.format("@%s%08X",getPackage(data),data);  
  149.         }  
  150.         if (dataType == TYPE_FLOAT) {  
  151.             return String.valueOf(Float.intBitsToFloat(data));  
  152.         }  
  153.         if (dataType == TYPE_INT_HEX) {  
  154.             return String.format("0x%08X",data);  
  155.         }  
  156.         if (dataType == TYPE_INT_BOOLEAN) {  
  157.             return data!=0?"true":"false";  
  158.         }  
  159.         if (dataType == TYPE_DIMENSION) {  
  160.             return Float.toString(complexToFloat(data))+  
  161.                 DIMENSION_UNITS[data & COMPLEX_UNIT_MASK];  
  162.         }  
  163.         if (dataType == TYPE_FRACTION) {  
  164.             return Float.toString(complexToFloat(data))+  
  165.                 FRACTION_UNITS[data & COMPLEX_UNIT_MASK];  
  166.         }  
  167.         if (dataType >= TYPE_FIRST_COLOR_INT && dataType <= TYPE_LAST_COLOR_INT) {  
  168.             return String.format("#%08X",data);  
  169.         }  
  170.         if (dataType >= TYPE_FIRST_INT && dataType <= TYPE_LAST_INT) {  
  171.             return String.valueOf(data);  
  172.         }  
  173.         return String.format("<0x%X, type 0x%02X>",data, dataType);  
  174.     }  
  175.       
  176.     private static String getPackage(int id) {  
  177.         if (id>>>24==1) {  
  178.             return "android:";  
  179.         }  
  180.         return "";  
  181.     }  
  182.       
  183.     public static float complexToFloat(int complex) {  
  184.         return (float)(complex & 0xFFFFFF00)*RADIX_MULTS[(complex>>4) & 3];  
  185.     }  
  186.       
  187.     private static final float RADIX_MULTS[]={  
  188.         0.00390625F,3.051758E-005F,1.192093E-007F,4.656613E-010F  
  189.     };  
  190.       
  191.     private static final String DIMENSION_UNITS[]={  
  192.         "px","dip","sp","pt","in","mm","",""  
  193.     };  
  194.       
  195.     private static final String FRACTION_UNITS[]={  
  196.         "%","%p","","","","","",""  
  197.     };  
  198.       
  199.     @Override  
  200.     public String toString(){  
  201.         return "size:"+size+",res0:"+res0+",dataType:"+getTypeStr()+",data:"+getDataStr();  
  202.     }  
  203.   
  204. }  

size：ResValue的头部大小

res0：保留，始终为0

dataType：数据的类型,可以从上面的枚举类型中获取

data：数据对应的索引

这里我们看到了有一个转化的方法，这个我们在解析AndroidManifest文件的时候也用到了这个方法。


实例：

图中画红线的部分就是一个ResTable_entry其后跟随的是一个Res_value的例子,从中我们可以得出以下信息,这个头部大小为8,flags等于0,所以后面跟随的是Res_value,在资源项名称字符串资源池中的索引为150,对应的值是badge_continue_months,Res_value的大小为8,数据的类型是TYPE_STRING,在资源项的值字符串资源池的索引为1912,对应的值是res/drawable-nodpi-v4/badge_continue_months.png。
当我们对arsc的文件格式有了了解过后,我们就可以开始我们的探索之旅了,由于在使用Android studio调试Apktool源码的时候遇到很多障碍,在前辈的指导下才能够顺利进行调试,所以下面简单介绍下设置Android studio调试Apktool源码的方法。




四、解析代码分析

因为篇幅的原因，这里就不把所有的代码都粘贴出来了，后面会列出来代码下载地址

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.FileInputStream;  
  5.   
  6. public class ParseResourceMain {  
  7.       
  8.     public static void main(String[] args){  
  9.           
  10.         byte[] srcByte = null;  
  11.         FileInputStream fis = null;  
  12.         ByteArrayOutputStream bos = null;  
  13.         try{  
  14.             fis = new FileInputStream("resource/resources_gdt1.arsc");  
  15.             bos = new ByteArrayOutputStream();  
  16.             byte[] buffer = new byte[1024];  
  17.             int len = 0;  
  18.             while((len=fis.read(buffer)) != -1){  
  19.                 bos.write(buffer, 0, len);  
  20.             }  
  21.             srcByte = bos.toByteArray();  
  22.         }catch(Exception e){  
  23.             System.out.println("read res file error:"+e.toString());  
  24.         }finally{  
  25.             try{  
  26.                 fis.close();  
  27.                 bos.close();  
  28.             }catch(Exception e){  
  29.                 System.out.println("close file error:"+e.toString());  
  30.             }  
  31.         }  
  32.           
  33.         if(srcByte == null){  
  34.             System.out.println("get src error...");  
  35.             return;  
  36.         }  
  37.           
  38.         System.out.println("parse restable header...");  
  39.         ParseResourceUtils.parseResTableHeaderChunk(srcByte);  
  40.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  41.         System.out.println();  
  42.           
  43.         System.out.println("parse resstring pool chunk...");  
  44.         ParseResourceUtils.parseResStringPoolChunk(srcByte);  
  45.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  46.         System.out.println();  
  47.           
  48.         System.out.println("parse package chunk...");  
  49.         ParseResourceUtils.parsePackage(srcByte);  
  50.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  51.         System.out.println();  
  52.           
  53.         System.out.println("parse typestring pool chunk...");  
  54.         ParseResourceUtils.parseTypeStringPoolChunk(srcByte);  
  55.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  56.         System.out.println();  
  57.           
  58.         System.out.println("parse keystring pool chunk...");  
  59.         ParseResourceUtils.parseKeyStringPoolChunk(srcByte);  
  60.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  61.         System.out.println();  
  62.           
  63.         int resCount = 0;  
  64.         while(!ParseResourceUtils.isEnd(srcByte.length)){  
  65.             resCount++;  
  66.             boolean isSpec = ParseResourceUtils.isTypeSpec(srcByte);  
  67.             if(isSpec){  
  68.                 System.out.println("parse restype spec chunk...");  
  69.                 ParseResourceUtils.parseResTypeSpec(srcByte);  
  70.                 System.out.println("++++++++++++++++++++++++++++++++++++++");  
  71.                 System.out.println();  
  72.             }else{  
  73.                 System.out.println("parse restype info chunk...");  
  74.                 ParseResourceUtils.parseResTypeInfo(srcByte);  
  75.                 System.out.println("++++++++++++++++++++++++++++++++++++++");  
  76.                 System.out.println();  
  77.             }  
  78.         }  
  79.         System.out.println("res count:"+resCount);  
  80.           
  81.     }  
  82.   
  83. }  
我们看到代码，首先我们读取resource.arsc文件到一个byte数组，然后开始解析。

第一、解析头部信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析头部信息 
  3.  * @param src 
  4.  */  
  5. public static void parseResTableHeaderChunk(byte[] src){  
  6.     ResTableHeader resTableHeader = new ResTableHeader();  
  7.   
  8.     resTableHeader.header = parseResChunkHeader(src, 0);  
  9.   
  10.     resStringPoolChunkOffset = resTableHeader.header.headerSize;  
  11.   
  12.     //解析PackageCount个数(一个apk可能包含多个Package资源)  
  13.     byte[] packageCountByte = Utils.copyByte(src, resTableHeader.header.getHeaderSize(), 4);  
  14.     resTableHeader.packageCount = Utils.byte2int(packageCountByte);  
  15.   
  16. }  
解析结果：



第二、解析资源字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析Resource.arsc文件中所有字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResStringPoolChunk(byte[] src){  
  6.     ResStringPoolHeader stringPoolHeader = parseStringPoolChunk(src, resStringList, resStringPoolChunkOffset);  
  7.     packageChunkOffset = resStringPoolChunkOffset + stringPoolHeader.header.size;  
  8. }  
这里有一个核心的方法：parseStringPoolChunk

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 统一解析字符串内容 
  3.  * @param src 
  4.  * @param stringList 
  5.  * @param stringOffset 
  6.  * @return 
  7.  */  
  8. public static ResStringPoolHeader parseStringPoolChunk(byte[] src, ArrayList<String> stringList, int stringOffset){  
  9.     ResStringPoolHeader stringPoolHeader = new ResStringPoolHeader();  
  10.   
  11.     //解析头部信息  
  12.     stringPoolHeader.header = parseResChunkHeader(src, stringOffset);  
  13.   
  14.     System.out.println("header size:"+stringPoolHeader.header.headerSize);  
  15.     System.out.println("size:"+stringPoolHeader.header.size);  
  16.   
  17.     int offset = stringOffset + stringPoolHeader.header.getHeaderSize();  
  18.   
  19.     //获取字符串的个数  
  20.     byte[] stringCountByte = Utils.copyByte(src, offset, 4);  
  21.     stringPoolHeader.stringCount = Utils.byte2int(stringCountByte);  
  22.   
  23.     //解析样式的个数  
  24.     byte[] styleCountByte = Utils.copyByte(src, offset+4, 4);  
  25.     stringPoolHeader.styleCount = Utils.byte2int(styleCountByte);  
  26.   
  27.     //这里表示字符串的格式:UTF-8/UTF-16  
  28.     byte[] flagByte = Utils.copyByte(src, offset+8, 4);  
  29.     System.out.println("flag:"+Utils.bytesToHexString(flagByte));  
  30.     stringPoolHeader.flags = Utils.byte2int(flagByte);  
  31.   
  32.     //字符串内容的开始位置  
  33.     byte[] stringStartByte = Utils.copyByte(src, offset+12, 4);  
  34.     stringPoolHeader.stringsStart = Utils.byte2int(stringStartByte);  
  35.     System.out.println("string start:"+Utils.bytesToHexString(stringStartByte));  
  36.   
  37.     //样式内容的开始位置  
  38.     byte[] sytleStartByte = Utils.copyByte(src, offset+16, 4);  
  39.     stringPoolHeader.stylesStart = Utils.byte2int(sytleStartByte);  
  40.     System.out.println("style start:"+Utils.bytesToHexString(sytleStartByte));  
  41.   
  42.     //获取字符串内容的索引数组和样式内容的索引数组  
  43.     int[] stringIndexAry = new int[stringPoolHeader.stringCount];  
  44.     int[] styleIndexAry = new int[stringPoolHeader.styleCount];  
  45.   
  46.     System.out.println("string count:"+stringPoolHeader.stringCount);  
  47.     System.out.println("style count:"+stringPoolHeader.styleCount);  
  48.   
  49.     int stringIndex = offset + 20;  
  50.     for(int i=0;i<stringPoolHeader.stringCount;i++){  
  51.         stringIndexAry[i] = Utils.byte2int(Utils.copyByte(src, stringIndex+i*4, 4));  
  52.     }  
  53.   
  54.     int styleIndex = stringIndex + 4*stringPoolHeader.stringCount;  
  55.     for(int i=0;i<stringPoolHeader.styleCount;i++){  
  56.         styleIndexAry[i] = Utils.byte2int(Utils.copyByte(src,  styleIndex+i*4, 4));  
  57.     }  
  58.   
  59.     //每个字符串的头两个字节的最后一个字节是字符串的长度  
  60.     //这里获取所有字符串的内容  
  61.     int stringContentIndex = styleIndex + stringPoolHeader.styleCount*4;  
  62.     System.out.println("string index:"+Utils.bytesToHexString(Utils.int2Byte(stringContentIndex)));  
  63.     int index = 0;  
  64.     while(index < stringPoolHeader.stringCount){  
  65.         byte[] stringSizeByte = Utils.copyByte(src, stringContentIndex, 2);  
  66.         int stringSize = (stringSizeByte[1] & 0x7F);  
  67.         if(stringSize != 0){  
  68.             String val = "";  
  69.             try{  
  70.                 val = new String(Utils.copyByte(src, stringContentIndex+2, stringSize), "utf-8");  
  71.             }catch(Exception e){  
  72.                 System.out.println("string encode error:"+e.toString());  
  73.             }  
  74.             stringList.add(val);  
  75.         }else{  
  76.             stringList.add("");  
  77.         }  
  78.         stringContentIndex += (stringSize+3);  
  79.         index++;  
  80.     }  
  81.     for(String str : stringList){  
  82.         System.out.println("str:"+str);  
  83.     }  
  84.   
  85.     return stringPoolHeader;  
  86.   
  87. }  
这里在得到一个字符串的时候，需要得到字符串的开始位置和字符串的大小即可，这点和解析AndroidManifest.xml文件中的字符串原理是一样的，就是一个字符串块的头两个字节中的最后一个字节是字符串的长度。这里我们在解析完字符串之后，需要用一个列表将其存储起来，后面有用到，需要通过索引来取字符串内容。

解析结果：



第三、解析包信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析Package信息 
  3.  * @param src 
  4.  */  
  5. public static void parsePackage(byte[] src){  
  6.     System.out.println("pchunkoffset:"+Utils.bytesToHexString(Utils.int2Byte(packageChunkOffset)));  
  7.     ResTablePackage resTabPackage = new ResTablePackage();  
  8.     //解析头部信息  
  9.     resTabPackage.header = parseResChunkHeader(src, packageChunkOffset);  
  10.   
  11.     System.out.println("package size:"+resTabPackage.header.headerSize);  
  12.   
  13.     int offset = packageChunkOffset + resTabPackage.header.getHeaderSize();  
  14.   
  15.     //解析packId  
  16.     byte[] idByte = Utils.copyByte(src, offset, 4);  
  17.     resTabPackage.id = Utils.byte2int(idByte);  
  18.     packId = resTabPackage.id;  
  19.   
  20.     //解析包名  
  21.     System.out.println("package offset:"+Utils.bytesToHexString(Utils.int2Byte(offset+4)));  
  22.     byte[] nameByte = Utils.copyByte(src, offset+4, 128*2);//这里的128是这个字段的大小，可以查看类型说明，是char类型的，所以要乘以2  
  23.     String packageName = new String(nameByte);  
  24.     packageName = Utils.filterStringNull(packageName);  
  25.     System.out.println("pkgName:"+packageName);  
  26.   
  27.     //解析类型字符串的偏移值  
  28.     byte[] typeStringsByte = Utils.copyByte(src, offset+4+128*2, 4);  
  29.     resTabPackage.typeStrings = Utils.byte2int(typeStringsByte);  
  30.     System.out.println("typeString:"+resTabPackage.typeStrings);  
  31.   
  32.     //解析lastPublicType字段  
  33.     byte[] lastPublicType = Utils.copyByte(src, offset+8+128*2, 4);  
  34.     resTabPackage.lastPublicType = Utils.byte2int(lastPublicType);  
  35.   
  36.     //解析keyString字符串的偏移值  
  37.     byte[] keyStrings = Utils.copyByte(src, offset+12+128*2, 4);  
  38.     resTabPackage.keyStrings = Utils.byte2int(keyStrings);  
  39.     System.out.println("keyString:"+resTabPackage.keyStrings);  
  40.   
  41.     //解析lastPublicKey  
  42.     byte[] lastPublicKey = Utils.copyByte(src, offset+12+128*2, 4);  
  43.     resTabPackage.lastPublicKey = Utils.byte2int(lastPublicKey);  
  44.   
  45.     //这里获取类型字符串的偏移值和类型字符串的偏移值  
  46.     keyStringPoolChunkOffset = (packageChunkOffset+resTabPackage.keyStrings);  
  47.     typeStringPoolChunkOffset = (packageChunkOffset+resTabPackage.typeStrings);  
  48.   
  49. }  
这里我们看到有一个特殊的地方，就是最后两行，这里需要得到我们后面需要重要解析的两个内容，一个是资源值字符串的偏移值和资源类型字符串的偏移值。

解析结果：



第四、解析资源类型的字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析类型字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseTypeStringPoolChunk(byte[] src){  
  6.     System.out.println("typestring offset:"+Utils.bytesToHexString(Utils.int2Byte(typeStringPoolChunkOffset)));  
  7.     ResStringPoolHeader stringPoolHeader = parseStringPoolChunk(src, typeStringList, typeStringPoolChunkOffset);  
  8.     System.out.println("size:"+stringPoolHeader.header.size);  
  9. }  
这里也是用parseStringPoolChunk方法进行解析的，同样也需要用一个字符串列表存储内容

解析结果：



第五、解析资源值字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析key字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseKeyStringPoolChunk(byte[] src){  
  6.     System.out.println("keystring offset:"+Utils.bytesToHexString(Utils.int2Byte(keyStringPoolChunkOffset)));  
  7.     ResStringPoolHeader stringPoolHeader  = parseStringPoolChunk(src, keyStringList, keyStringPoolChunkOffset);  
  8.     System.out.println("size:"+stringPoolHeader.header.size);  
  9.     //解析完key字符串之后，需要赋值给resType的偏移值,后续还需要继续解析  
  10.     resTypeOffset = (keyStringPoolChunkOffset+stringPoolHeader.header.size);  
  11. }  
这里也是一样，使用parseStringPoolChunk方法来解析，解析完之后需要用一个字符串列表保存，后面需要使用索引值来访问

解析结果：



第六、解析正文内容

这里说到的正文内容就是ResValue值，也就是开始构建public.xml中的条目信息，和类型的分离不同的xml文件，所以这部分的内容的解析工作有点复杂

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. int resCount = 0;  
  2. while(!ParseResourceUtils.isEnd(srcByte.length)){  
  3.     resCount++;  
  4.     boolean isSpec = ParseResourceUtils.isTypeSpec(srcByte);  
  5.     if(isSpec){  
  6.         System.out.println("parse restype spec chunk...");  
  7.         ParseResourceUtils.parseResTypeSpec(srcByte);  
  8.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  9.         System.out.println();  
  10.     }else{  
  11.         System.out.println("parse restype info chunk...");  
  12.         ParseResourceUtils.parseResTypeInfo(srcByte);  
  13.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  14.         System.out.println();  
  15.     }  
  16. }  
  17. System.out.println("res count:"+resCount);  
这里有一个循环解析，有两个方法，一个是isEnd方法，一个是isTypeSpec方法

我们如果仔细看上面的那张神图的话，就可以看到，后面的ResType和ResTypeSpec他们两个内容是交替出现的，直到文件结束。

所以isEnd方法就是判断是否到达文件结束位置：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 判断是否到文件末尾了 
  3.  * @param length 
  4.  * @return 
  5.  */  
  6. public static boolean isEnd(int length){  
  7.     if(resTypeOffset>=length){  
  8.         return true;  
  9.     }  
  10.     return false;  
  11. }  

还有一个方法就是判断是ResType还是ResTypeSpec，这个可以通过Chunk中头部信息来区分的：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 判断是不是类型描述符 
  3.  * @param src 
  4.  * @return 
  5.  */  
  6. public static boolean isTypeSpec(byte[] src){  
  7.     ResChunkHeader header = parseResChunkHeader(src, resTypeOffset);  
  8.     if(header.type == 0x0202){  
  9.         return true;  
  10.     }  
  11.     return false;  
  12. }  
那么就是分别来解析ResTypeSpec和ResType这两个内容了：

1、解析ResTypeSpec

主要得到Res的每个类型名

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析ResTypeSepc类型描述内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResTypeSpec(byte[] src){  
  6.     System.out.println("res type spec offset:"+Utils.bytesToHexString(Utils.int2Byte(resTypeOffset)));  
  7.     ResTableTypeSpec typeSpec = new ResTableTypeSpec();  
  8.     //解析头部信息  
  9.     typeSpec.header = parseResChunkHeader(src, resTypeOffset);  
  10.   
  11.     int offset = (resTypeOffset + typeSpec.header.getHeaderSize());  
  12.   
  13.     //解析id类型  
  14.     byte[] idByte = Utils.copyByte(src, offset, 1);  
  15.     typeSpec.id = (byte)(idByte[0] & 0xFF);  
  16.     resTypeId = typeSpec.id;  
  17.   
  18.     //解析res0字段,这个字段是备用的，始终是0  
  19.     byte[] res0Byte = Utils.copyByte(src, offset+1, 1);  
  20.     typeSpec.res0 = (byte)(res0Byte[0] & 0xFF);  
  21.   
  22.     //解析res1字段，这个字段是备用的，始终是0  
  23.     byte[] res1Byte = Utils.copyByte(src, offset+2, 2);  
  24.     typeSpec.res1 = Utils.byte2Short(res1Byte);  
  25.   
  26.     //entry的总个数  
  27.     byte[] entryCountByte = Utils.copyByte(src, offset+4, 4);  
  28.     typeSpec.entryCount = Utils.byte2int(entryCountByte);  
  29.   
  30.     System.out.println("res type spec:"+typeSpec);  
  31.   
  32.     System.out.println("type_name:"+typeStringList.get(typeSpec.id-1));  
  33.   
  34.     //获取entryCount个int数组  
  35.     int[] intAry = new int[typeSpec.entryCount];  
  36.     int intAryOffset = resTypeOffset + typeSpec.header.headerSize;  
  37.     System.out.print("int element:");  
  38.     for(int i=0;i<typeSpec.entryCount;i++){  
  39.         int element = Utils.byte2int(Utils.copyByte(src, intAryOffset+i*4, 4));  
  40.         intAry[i] = element;  
  41.         System.out.print(element+",");  
  42.     }  
  43.     System.out.println();  
  44.   
  45.     resTypeOffset += typeSpec.header.size;  
  46.   
  47. }  

解析结果：



2、解析ResType

主要得到每个res类型的所有条目内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析类型信息内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResTypeInfo(byte[] src){  
  6.     System.out.println("type chunk offset:"+Utils.bytesToHexString(Utils.int2Byte(resTypeOffset)));  
  7.     ResTableType type = new ResTableType();  
  8.     //解析头部信息  
  9.     type.header = parseResChunkHeader(src, resTypeOffset);  
  10.   
  11.     int offset = (resTypeOffset + type.header.getHeaderSize());  
  12.   
  13.     //解析type的id值  
  14.     byte[] idByte = Utils.copyByte(src, offset, 1);  
  15.     type.id = (byte)(idByte[0] & 0xFF);  
  16.   
  17.     //解析res0字段的值，备用字段，始终是0  
  18.     byte[] res0 = Utils.copyByte(src, offset+1, 1);  
  19.     type.res0 = (byte)(res0[0] & 0xFF);  
  20.   
  21.     //解析res1字段的值，备用字段，始终是0  
  22.     byte[] res1 = Utils.copyByte(src, offset+2, 2);  
  23.     type.res1 = Utils.byte2Short(res1);  
  24.   
  25.     byte[] entryCountByte = Utils.copyByte(src, offset+4, 4);  
  26.     type.entryCount = Utils.byte2int(entryCountByte);  
  27.   
  28.     byte[] entriesStartByte = Utils.copyByte(src, offset+8, 4);  
  29.     type.entriesStart = Utils.byte2int(entriesStartByte);  
  30.   
  31.     ResTableConfig resConfig = new ResTableConfig();  
  32.     resConfig = parseResTableConfig(Utils.copyByte(src, offset+12, resConfig.getSize()));  
  33.     System.out.println("config:"+resConfig);  
  34.   
  35.     System.out.println("res type info:"+type);  
  36.   
  37.     System.out.println("type_name:"+typeStringList.get(type.id-1));  
  38.   
  39.     //先获取entryCount个int数组  
  40.     System.out.print("type int elements:");  
  41.     int[] intAry = new int[type.entryCount];  
  42.     for(int i=0;i<type.entryCount;i++){  
  43.         int element = Utils.byte2int(Utils.copyByte(src, resTypeOffset+type.header.headerSize+i*4, 4));  
  44.         intAry[i] = element;  
  45.         System.out.print(element+",");  
  46.     }  
  47.     System.out.println();  
  48.   
  49.     //这里开始解析后面对应的ResEntry和ResValue  
  50.     int entryAryOffset = resTypeOffset + type.entriesStart;  
  51.     ResTableEntry[] tableEntryAry = new ResTableEntry[type.entryCount];  
  52.     ResValue[] resValueAry = new ResValue[type.entryCount];  
  53.     System.out.println("entry offset:"+Utils.bytesToHexString(Utils.int2Byte(entryAryOffset)));  
  54.   
  55.     //这里存在一个问题就是如果是ResMapEntry的话，偏移值是不一样的，所以这里需要计算不同的偏移值  
  56.     int bodySize = 0, valueOffset = entryAryOffset;  
  57.     for(int i=0;i<type.entryCount;i++){  
  58.         int resId = getResId(i);  
  59.         System.out.println("resId:"+Utils.bytesToHexString(Utils.int2Byte(resId)));  
  60.         ResTableEntry entry = new ResTableEntry();  
  61.         ResValue value = new ResValue();  
  62.         valueOffset += bodySize;  
  63.         System.out.println("valueOffset:"+Utils.bytesToHexString(Utils.int2Byte(valueOffset)));  
  64.         entry = parseResEntry(Utils.copyByte(src, valueOffset, entry.getSize()));  
  65.   
  66.         //这里需要注意的是，先判断entry的flag变量是否为1,如果为1的话，那就ResTable_map_entry  
  67.         if(entry.flags == 1){  
  68.             //这里是复杂类型的value  
  69.             ResTableMapEntry mapEntry = new ResTableMapEntry();  
  70.             mapEntry = parseResMapEntry(Utils.copyByte(src, valueOffset, mapEntry.getSize()));  
  71.             System.out.println("map entry:"+mapEntry);  
  72.             ResTableMap resMap = new ResTableMap();  
  73.             for(int j=0;j<mapEntry.count;j++){  
  74.                 int mapOffset = valueOffset + mapEntry.getSize() + resMap.getSize()*j;  
  75.                 resMap = parseResTableMap(Utils.copyByte(src, mapOffset, resMap.getSize()));  
  76.                 System.out.println("map:"+resMap);  
  77.             }  
  78.             bodySize = mapEntry.getSize() + resMap.getSize()*mapEntry.count;  
  79.         }else{  
  80.             System.out.println("entry:"+entry);  
  81.             //这里是简单的类型的value  
  82.             value = parseResValue(Utils.copyByte(src, valueOffset+entry.getSize(), value.getSize()));  
  83.             System.out.println("value:"+value);  
  84.             bodySize = entry.getSize()+value.getSize();  
  85.         }  
  86.   
  87.         tableEntryAry[i] = entry;  
  88.         resValueAry[i] = value;  
  89.   
  90.         System.out.println("======================================");  
  91.     }  
  92.   
  93.     resTypeOffset += type.header.size;  
  94.   
  95. }  
  96.   
  97. /** 
  98.  * 解析ResEntry内容 
  99.  * @param src 
  100.  * @return 
  101.  */  
  102. public static ResTableEntry parseResEntry(byte[] src){  
  103.     ResTableEntry entry = new ResTableEntry();  
  104.   
  105.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  106.     entry.size = Utils.byte2Short(sizeByte);  
  107.   
  108.     byte[] flagByte = Utils.copyByte(src, 2, 2);  
  109.     entry.flags = Utils.byte2Short(flagByte);  
  110.   
  111.     ResStringPoolRef key = new ResStringPoolRef();  
  112.     byte[] keyByte = Utils.copyByte(src, 4, 4);  
  113.     key.index = Utils.byte2int(keyByte);  
  114.     entry.key = key;  
  115.   
  116.     return entry;  
  117. }  
  118.   
  119. /** 
  120.  * 解析ResMapEntry内容 
  121.  * @param src 
  122.  * @return 
  123.  */  
  124. public static ResTableMapEntry parseResMapEntry(byte[] src){  
  125.     ResTableMapEntry entry = new ResTableMapEntry();  
  126.   
  127.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  128.     entry.size = Utils.byte2Short(sizeByte);  
  129.   
  130.     byte[] flagByte = Utils.copyByte(src, 2, 2);  
  131.     entry.flags = Utils.byte2Short(flagByte);  
  132.   
  133.     ResStringPoolRef key = new ResStringPoolRef();  
  134.     byte[] keyByte = Utils.copyByte(src, 4, 4);  
  135.     key.index = Utils.byte2int(keyByte);  
  136.     entry.key = key;  
  137.   
  138.     ResTableRef ref = new ResTableRef();  
  139.     byte[] identByte = Utils.copyByte(src, 8, 4);  
  140.     ref.ident = Utils.byte2int(identByte);  
  141.     entry.parent = ref;  
  142.     byte[] countByte = Utils.copyByte(src, 12, 4);  
  143.     entry.count = Utils.byte2int(countByte);  
  144.   
  145.     return entry;  
  146. }  
  147.   
  148. /** 
  149.  * 解析ResValue内容 
  150.  * @param src 
  151.  * @return 
  152.  */  
  153. public static ResValue parseResValue(byte[] src){  
  154.     ResValue resValue = new ResValue();  
  155.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  156.     resValue.size = Utils.byte2Short(sizeByte);  
  157.   
  158.     byte[] res0Byte = Utils.copyByte(src, 2, 1);  
  159.     resValue.res0 = (byte)(res0Byte[0] & 0xFF);  
  160.   
  161.     byte[] dataType = Utils.copyByte(src, 3, 1);  
  162.     resValue.dataType = (byte)(dataType[0] & 0xFF);  
  163.   
  164.     byte[] data = Utils.copyByte(src, 4, 4);  
  165.     resValue.data = Utils.byte2int(data);  
  166.   
  167.     return resValue;  
  168. }  
  169.   
  170. /** 
  171.  * 解析ResTableMap内容 
  172.  * @param src 
  173.  * @return 
  174.  */  
  175. public static ResTableMap parseResTableMap(byte[] src){  
  176.     ResTableMap tableMap = new ResTableMap();  
  177.   
  178.     ResTableRef ref = new ResTableRef();  
  179.     byte[] identByte = Utils.copyByte(src, 0, ref.getSize());  
  180.     ref.ident = Utils.byte2int(identByte);  
  181.     tableMap.name = ref;  
  182.   
  183.     ResValue value = new ResValue();  
  184.     value = parseResValue(Utils.copyByte(src, ref.getSize(), value.getSize()));  
  185.     tableMap.value = value;  
  186.   
  187.     return tableMap;  
  188.   
  189. }  
  190.   
  191. /** 
  192.  * 解析ResTableConfig配置信息 
  193.  * @param src 
  194.  * @return 
  195.  */  
  196. public static ResTableConfig parseResTableConfig(byte[] src){  
  197.     ResTableConfig config = new ResTableConfig();  
  198.   
  199.     byte[] sizeByte = Utils.copyByte(src, 0, 4);  
  200.     config.size = Utils.byte2int(sizeByte);  
  201.   
  202.     //以下结构是Union  
  203.     byte[] mccByte = Utils.copyByte(src, 4, 2);  
  204.     config.mcc = Utils.byte2Short(mccByte);  
  205.     byte[] mncByte = Utils.copyByte(src, 6, 2);  
  206.     config.mnc = Utils.byte2Short(mncByte);  
  207.     byte[] imsiByte = Utils.copyByte(src, 4, 4);  
  208.     config.imsi = Utils.byte2int(imsiByte);  
  209.   
  210.     //以下结构是Union  
  211.     byte[] languageByte = Utils.copyByte(src, 8, 2);  
  212.     config.language = languageByte;  
  213.     byte[] countryByte = Utils.copyByte(src, 10, 2);  
  214.     config.country = countryByte;  
  215.     byte[] localeByte = Utils.copyByte(src, 8, 4);  
  216.     config.locale = Utils.byte2int(localeByte);  
  217.   
  218.     //以下结构是Union  
  219.     byte[] orientationByte = Utils.copyByte(src, 12, 1);  
  220.     config.orientation = orientationByte[0];  
  221.     byte[] touchscreenByte = Utils.copyByte(src, 13, 1);  
  222.     config.touchscreen = touchscreenByte[0];  
  223.     byte[] densityByte = Utils.copyByte(src, 14, 2);  
  224.     config.density = Utils.byte2Short(densityByte);  
  225.     byte[] screenTypeByte = Utils.copyByte(src, 12, 4);  
  226.     config.screenType = Utils.byte2int(screenTypeByte);  
  227.   
  228.     //以下结构是Union  
  229.     byte[] keyboardByte = Utils.copyByte(src, 16, 1);  
  230.     config.keyboard = keyboardByte[0];  
  231.     byte[] navigationByte = Utils.copyByte(src, 17, 1);  
  232.     config.navigation = navigationByte[0];  
  233.     byte[] inputFlagsByte = Utils.copyByte(src, 18, 1);  
  234.     config.inputFlags = inputFlagsByte[0];  
  235.     byte[] inputPad0Byte = Utils.copyByte(src, 19, 1);  
  236.     config.inputPad0 = inputPad0Byte[0];  
  237.     byte[] inputByte = Utils.copyByte(src, 16, 4);  
  238.     config.input = Utils.byte2int(inputByte);  
  239.   
  240.     //以下结构是Union  
  241.     byte[] screenWidthByte = Utils.copyByte(src, 20, 2);  
  242.     config.screenWidth = Utils.byte2Short(screenWidthByte);  
  243.     byte[] screenHeightByte = Utils.copyByte(src, 22, 2);  
  244.     config.screenHeight = Utils.byte2Short(screenHeightByte);  
  245.     byte[] screenSizeByte = Utils.copyByte(src, 20, 4);  
  246.     config.screenSize = Utils.byte2int(screenSizeByte);  
  247.   
  248.     //以下结构是Union  
  249.     byte[] sdVersionByte = Utils.copyByte(src, 24, 2);  
  250.     config.sdVersion = Utils.byte2Short(sdVersionByte);  
  251.     byte[] minorVersionByte = Utils.copyByte(src, 26, 2);  
  252.     config.minorVersion = Utils.byte2Short(minorVersionByte);  
  253.     byte[] versionByte = Utils.copyByte(src, 24, 4);  
  254.     config.version = Utils.byte2int(versionByte);  
  255.   
  256.     //以下结构是Union  
  257.     byte[] screenLayoutByte = Utils.copyByte(src, 28, 1);  
  258.     config.screenLayout = screenLayoutByte[0];  
  259.     byte[] uiModeByte = Utils.copyByte(src, 29, 1);  
  260.     config.uiMode = uiModeByte[0];  
  261.     byte[] smallestScreenWidthDpByte = Utils.copyByte(src, 30, 2);  
  262.     config.smallestScreenWidthDp = Utils.byte2Short(smallestScreenWidthDpByte);  
  263.     byte[] screenConfigByte = Utils.copyByte(src, 28, 4);  
  264.     config.screenConfig = Utils.byte2int(screenConfigByte);  
  265.   
  266.     //以下结构是Union  
  267.     byte[] screenWidthDpByte = Utils.copyByte(src, 32, 2);  
  268.     config.screenWidthDp = Utils.byte2Short(screenWidthDpByte);  
  269.     byte[] screenHeightDpByte = Utils.copyByte(src, 34, 2);  
  270.     config.screenHeightDp = Utils.byte2Short(screenHeightDpByte);  
  271.     byte[] screenSizeDpByte = Utils.copyByte(src, 32, 4);  
  272.     config.screenSizeDp = Utils.byte2int(screenSizeDpByte);  
  273.   
  274.     byte[] localeScriptByte = Utils.copyByte(src, 36, 4);  
  275.     config.localeScript = localeScriptByte;  
  276.   
  277.     byte[] localeVariantByte = Utils.copyByte(src, 40, 8);  
  278.     config.localeVariant = localeVariantByte;  
  279.     return config;  
  280. }  
看到这里，我们发现这里的解析很复杂的，和我们在讲解数据结构的时候那里一样，他需要解析很多内容：

ResValue，ResTableMap，ResTableMapEntry，ResTableEntry，ResConfig

关于每个数据结构如何解析这里就不多说了，就是读取字节即可。这里有一个核心的代码：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. //这里需要注意的是，先判断entry的flag变量是否为1,如果为1的话，那就ResTable_map_entry  
  2. if(entry.flags == 1){  
  3.     //这里是复杂类型的value  
  4.     ResTableMapEntry mapEntry = new ResTableMapEntry();  
  5.     mapEntry = parseResMapEntry(Utils.copyByte(src, valueOffset, mapEntry.getSize()));  
  6.     System.out.println("map entry:"+mapEntry);  
  7.     ResTableMap resMap = new ResTableMap();  
  8.     for(int j=0;j<mapEntry.count;j++){  
  9.         int mapOffset = valueOffset + mapEntry.getSize() + resMap.getSize()*j;  
  10.         resMap = parseResTableMap(Utils.copyByte(src, mapOffset, resMap.getSize()));  
  11.         System.out.println("map:"+resMap);  
  12.     }  
  13.     bodySize = mapEntry.getSize() + resMap.getSize()*mapEntry.count;  
  14. }else{  
  15.     System.out.println("entry:"+entry);  
  16.     //这里是简单的类型的value  
  17.     value = parseResValue(Utils.copyByte(src, valueOffset+entry.getSize(), value.getSize()));  
  18.     System.out.println("value:"+value);  
  19.     bodySize = entry.getSize()+value.getSize();  
  20. }  
判断flag的值，来进行不同的解析操作。这里需要注意这点。

解析结果：



看到解析结果，还是挺欣慰的，因为最难的地方我们解析成功了，而且看到结果我们很激动，就是我们想要的结果，但是这里需要解释的是，有了这些值我们构建public.xml内容和各个类型的xml内容是很简单，当然这里我们去构建了，感兴趣的同学可以去尝试一下。

注意：这里的ResId的构造方法是：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 获取资源id 
  3.  * 这里高位是packid，中位是restypeid，地位是entryid 
  4.  * @param entryid 
  5.  * @return 
  6.  */  
  7. public static int getResId(int entryid){  
  8.     return (((packId)<<24) | (((resTypeId) & 0xFF)<<16) | (entryid & 0xFFFF));  
  9. }  
这里我们可以看到就是一个int类型的resId，

他的最高两个字节表示packId,系统资源id是：0x01，普通应用资源id是：0x7F

他的中间的两个字节表示resTypeId，类型id,这个值从0开始，比如我们例子中第一个类型是attr，那么他的resTypeId就是00

他的最低四个字节表示这个资源的顺序id，从1开始，逐渐累加1


项目下载地址：https://github.com/fourbrother/parse_androidarsc


五、技术概述

上面我们就很蛋疼的解析完了所有的resource.arsc文件，当然内容有点多，所以有些地方可能没介绍清楚或者是有错误的地方，请多指正。当然关于Android编译之后的四个文件格式，我们已经介绍了三个了：

so文件格式、AndroidManifest.xml格式/资源文件.xml、resource.arsc

那么剩下就只有classes.dex这一个文件格式了，我们就算大功告成了。但是我想在这里说的是，这篇文章我们主要是介绍解析resource.arsc文件格式，那么写这篇文章的目的是什么呢？

有两个：

1、我们在使用apktool工具进行反编译的时候，经常出现一些莫名的一场信息，最多的就是NotFound ResId 0x0000XXX这些内容，那么这时候我们就可以去修复了，当然我们可以得到apktool的源码来解决这个问题，还可以就是使用我们自己写的这套解析代码也是可以的。

2、我们之前提过，解析resource.arsc文件之后，对resource.arsc文件格式如果有了解了之后，可以对资源文件名进行混淆，从而来减小apk包大小，我在之前的一篇文章：

Apk的签名机制：http://blog.csdn.net/jiangwei0910410003/article/details/50402000

因为META-INF文件夹下的三个文件大小很大，原因就是他们内部保存了每个资源名称，我们在项目中有时候为了不造成冲突，就把资源名起的很长，那么这样就会导致apk的包很大。

同样resource.arsc文件也会很大，因为资源名都是需要保存的，但是我们知道Android中的混淆是不会对资源文件进行混淆的，所以这时候我们就可以通过这个思路来减小包apk的大小了。这个后续我会继续讲解的。


注意：

到这里我们还需要告诉一件事，那就是其实我们上面的解析工作，有一个更简单的方法就可以搞定了？那就是aapt命令？关于这个aapt是干啥的？网上有很多资料，他其实很简单就是将Android中的资源文件打包成resource.arsc即可:


只有那些类型为res/animator、res/anim、res/color、res/drawable（非Bitmap文件，即非.png、.9.png、.jpg、.gif文件）、res/layout、res/menu、res/values和res/xml的资源文件均会从文本格式的XML文件编译成二进制格式的XML文件
这些XML资源文件之所要从文本格式编译成二进制格式，是因为：
1. 二进制格式的XML文件占用空间更小。这是由于所有XML元素的标签、属性名称、属性值和内容所涉及到的字符串都会被统一收集到一个字符串资源池中去，并且会去重。有了这个字符串资源池，原来使用字符串的地方就会被替换成一个索引到字符串资源池的整数值，从而可以减少文件的大小。
2. 二进制格式的XML文件解析速度更快。这是由于二进制格式的XML元素里面不再包含有字符串值，因此就避免了进行字符串解析，从而提高速度。
将XML资源文件从文本格式编译成二进制格式解决了空间占用以及解析效率的问题，但是对于Android资源管理框架来说，这只是完成了其中的一部分工作。Android资源管理框架的另外一个重要任务就是要根据资源ID来快速找到对应的资源。

那么下面我们用aapt命令就可以查看一下？

aapt命令在我们的AndroidSdk目录中：


看到路径了：Android-SDK目录/build-tools/下面

我们也就知道了，这个目录下全是Android中build成一个apk的所有工具，这里再看一下这些工具的用途：


1、使用Android SDK提供的aapt.exe生成R.Java类文件
2、使用Android SDK提供的aidl.exe把.aidl转成.java文件（如果没有aidl，则跳过这一步）
3、使用JDK提供的javac.exe编译.java类文件生成class文件
4、使用Android SDK提供的dx.bat命令行脚本生成classes.dex文件
5、使用Android SDK提供的aapt.exe生成资源包文件（包括res、assets、androidmanifest.xml等）
6、使用Android SDK提供的apkbuilder.bat生成未签名的apk安装文件
7、使用jdk的jarsigner.exe对未签名的包进行apk签名

看到了吧。我们原来可以不借助任何IDE工具，也是可以出一个apk包的。哈哈~~

继续看aapt命令的用法，命令很简单：

aapt l -a apk名称 > demo.txt

将输入的结果定向到demo.txt中


看到我们弄出来的内容，发现就是我们上面解析的AndroidManifest.xml内容，所以这个也是一个方法，当然aapt命令这里我为什么最后说呢？之前我们讲解的AndroidManifest.xml格式肯定是有用的，aapt命令只是系统提供给我们一个很好的工具，我们可以在反编译的过程中借助这个工具也是不错的选择。所以这里我就想说，以后我们记得有一个aapt命令就好了，他的用途还是很多的，可以单独编译成一个resource.arsc文件来，我们后面会用到这个命令。


感谢原作。



Android逆向之旅-Resource.arsc文件格式

2017-03-05   JemenChen   转自 fishpan_oli...
修改
微信 分享：

一、前言

快过年了，先提前祝贺大家新年快乐，这篇文章也是今年最后一篇了。今天我们继续来看逆向的相关知识，前篇文章中我们介绍了如何解析Android中编译之后的AndroidManifest.xml文件格式：http://blog.csdn.net/jiangwei0910410003/article/details/50568487

当时我说到其实后续还要继续介绍两个文件一个是resource.arsc和classes.dex，今天我们就来看看resource.arsc文件个格式解析，classes.dex的解析要等年后了。


二、准备工作

我们在使用apktool工具进行反编译的时候，会发现有一个：res/values/public.xml这个文件：


我们查看一下public.xml文件内容：


看到了，这个文件就保存了apk中所有的类型和对应的id值，我们看到这里面的每个条目内容都是：

type：类型名

name：资源名

id：资源的id

类型的话有这么几种：

drawable，menu，layout，string，attr，color，style等

所以我们会在反编译之后的文件夹中看到这几个类型的文件xml内容。


上面我们介绍了如何使用apktool反编译之后的内容，下面我们要做的事情就是如何来解析resource.arsc文件，解析出这些文件。

我们解压一个apk得到对应的resource.arsc文件。按照国际惯例，每个文件的格式描述都是有对应的数据结构的，resource也不例外：frameworks\base\include\androidfw\ResourceTypes.h，这就是resource中定义的所有数据结构。

下面再来看一张神图：


每次我们在解析文件的时候都会有一张神图，我们按照这张图来进行数据解析工作。


三、数据结构定义


这个是项目工程结构，我们看到定义了很多的数据结构

第一、头部信息

Resources.arsc文件格式是由一系列的chunk构成,每一个chunk均包含如下结构的ResChunk_header,用来描述这个chunk的基本信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.Utils;  
  4.   
  5. /** 
  6. struct ResChunk_header 
  7. { 
  8.     // Type identifier for this chunk.  The meaning of this value depends 
  9.     // on the containing chunk. 
  10.     uint16_t type; 
  11.  
  12.     // Size of the chunk header (in bytes).  Adding this value to 
  13.     // the address of the chunk allows you to find its associated data 
  14.     // (if any). 
  15.     uint16_t headerSize; 
  16.  
  17.     // Total size of this chunk (in bytes).  This is the chunkSize plus 
  18.     // the size of any data associated with the chunk.  Adding this value 
  19.     // to the chunk allows you to completely skip its contents (including 
  20.     // any child chunks).  If this value is the same as chunkSize, there is 
  21.     // no data associated with the chunk. 
  22.     uint32_t size; 
  23. }; 
  24.  * @author i 
  25.  * 
  26.  */  
  27. public class ResChunkHeader {  
  28.       
  29.     public short type;  
  30.     public short headerSize;  
  31.     public int size;  
  32.       
  33.     public int getHeaderSize(){  
  34.         return 2+2+4;  
  35.     }  
  36.       
  37.     @Override  
  38.     public String toString(){  
  39.         return "type:"+Utils.bytesToHexString(Utils.int2Byte(type))+",headerSize:"+headerSize+",size:"+size;  
  40.     }  
  41.   
  42. }  
type：是当前这个chunk的类型

headerSize：是当前这个chunk的头部大小

size：是当前这个chunk的大小


第二、资源索引表的头部信息

Resources.arsc文件的第一个结构是资源索引表头部。其结构如下,描述了Resources.arsc文件的大小和资源包数量。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_header 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // The number of ResTable_package structures. 
  9.     uint32_t packageCount; 
  10. }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableHeader {  
  15.   
  16.     public ResChunkHeader header;  
  17.     public int packageCount;  
  18.       
  19.     public ResTableHeader(){  
  20.         header = new ResChunkHeader();  
  21.     }  
  22.       
  23.     public int getHeaderSize(){  
  24.         return header.getHeaderSize() + 4;  
  25.     }  
  26.       
  27.     @Override  
  28.     public String toString(){  
  29.         return "header:"+header.toString()+"\n" + "packageCount:"+packageCount;  
  30.     }  
  31.       
  32. }  

header：就是标准的Chunk头部信息格式

packageCount：被编译的资源包的个数

Android中一个apk可能包含多个资源包，默认情况下都只有一个就是应用的包名所在的资源包

实例：

图中蓝色高亮的部分就是资源索引表头部。通过解析,我们可以得到如下信息,这个chunk的类型为RES_TABLE_TYPE,头部大小为0XC,整个chunk的大小为1400252byte,有一个编译好的资源包。



第三、资源项的值字符串资源池

紧跟着资源索引表头部的是资源项的值字符串资源池,这个字符串资源池包含了所有的在资源包里面所定义的资源项的值字符串,字符串资源池头部的结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResStringPool_header 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // Number of strings in this pool (number of uint32_t indices that follow 
  9.     // in the data). 
  10.     uint32_t stringCount; 
  11.  
  12.     // Number of style span arrays in the pool (number of uint32_t indices 
  13.     // follow the string indices). 
  14.     uint32_t styleCount; 
  15.  
  16.     // Flags. 
  17.     enum { 
  18.         // If set, the string index is sorted by the string values (based 
  19.         // on strcmp16()). 
  20.         SORTED_FLAG = 1<<0, 
  21.  
  22.         // String pool is encoded in UTF-8 
  23.         UTF8_FLAG = 1<<8 
  24.     }; 
  25.     uint32_t flags; 
  26.  
  27.     // Index from header of the string data. 
  28.     uint32_t stringsStart; 
  29.  
  30.     // Index from header of the style data. 
  31.     uint32_t stylesStart; 
  32. }; 
  33.  * @author i 
  34.  * 
  35.  */  
  36. public class ResStringPoolHeader {  
  37.       
  38.     public ResChunkHeader header;  
  39.     public int stringCount;  
  40.     public int styleCount;  
  41.       
  42.     public final static int SORTED_FLAG = 1;  
  43.     public final static int UTF8_FLAG = (1<<8);  
  44.       
  45.     public int flags;  
  46.     public int stringsStart;  
  47.     public int stylesStart;  
  48.       
  49.     public ResStringPoolHeader(){  
  50.         header = new ResChunkHeader();  
  51.     }  
  52.       
  53.     public int getHeaderSize(){  
  54.         return header.getHeaderSize() + 4 + 4 + 4 + 4 + 4;  
  55.     }  
  56.       
  57.     @Override  
  58.     public String toString(){  
  59.         return "header:"+header.toString()+"\n" + "stringCount:"+stringCount+",styleCount:"+styleCount+",flags:"+flags+",stringStart:"+stringsStart+",stylesStart:"+stylesStart;  
  60.     }  
  61.       
  62. }  

header：标准的Chunk头部信息结构

stringCount：字符串的个数

styleCount：字符串样式的个数

flags：字符串的属性,可取值包括0x000(UTF-16),0x001(字符串经过排序)、0X100(UTF-8)和他们的组合值

stringStart：字符串内容块相对于其头部的距离

stylesStart：字符串样式块相对于其头部的距离

实例：


图中绿色高亮的部分就是字符串资源池头部,通过解析,我们可以得到如下信息,这个chunk的类型为RES_STRING_POOL_TYPE,即字符串资源池。头部大小为0X1C,整个chunk的大小为369524byte,有8073条字符串,72个字符串样式,为UTF-8编码,无排序,字符串内容块相对于此chunk头部的偏移为0X7F60,字符串样式块相对于此chunk头部的偏移为0X5A054。
紧接着头部的的是两个偏移数组，分别是字符串偏移数组和字符串样式偏移数组。这两个偏移数组的大小分别等于stringCount和styleCount的值，而每一个元素的类型都是无符号整型。整个字符中资源池结构如下。


字符串资源池中的字符串前两个字节为字符串长度,长度计算方法如下。另外如果字符串编码格式为UTF-8则字符串以0X00作为结束符,UTF-16则以0X0000作为结束符。
len = (((hbyte & 0x7F) << 8)) | lbyte;
字符串与字符串样式有一一对应的关系,也就是说如果第n个字符串有样式,则它的样式描述位于样式块的第n个元素。 字符串样式的结构包括如下两个结构体,ResStringPool_ref和ResStringPool_span。 一个字符串可以对应多个ResStringPool_span和一个ResStringPool_ref。ResStringPool_span在前描述字符串的样式,ResStringPool_ref在后固定值为0XFFFFFFFF作为占位符。样式块最后会以两个值为0XFFFFFFFF的ResStringPool_ref作为结束。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResStringPool_ref 
  5.  { 
  6.      uint32_t index; 
  7.  }; 
  8.   
  9.  * @author i 
  10.  * 
  11.  */  
  12. public class ResStringPoolRef {  
  13.   
  14.     public int index;  
  15.       
  16.     public int getSize(){  
  17.         return 4;  
  18.     }  
  19.       
  20.     @Override  
  21.     public String toString(){  
  22.         return "index:"+index;  
  23.     }  
  24.       
  25. }  

实例：


图中蓝色高亮的部分就是样式内容块,按照格式解析可以得出,第一个字符串和第二字符串无样式,第三个字符串第4个字符到第7个字符的位置样式为字符串资源池中0X1F88的字符,以此类推。


第四、Package数据块

接着资源项的值字符串资源池后面的部分就是Package数据块,这个数据块记录编译包的元数据,头部结构如下：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_package 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // If this is a base package, its ID.  Package IDs start 
  9.     // at 1 (corresponding to the value of the package bits in a 
  10.     // resource identifier).  0 means this is not a base package. 
  11.     uint32_t id; 
  12.  
  13.     // Actual name of this package, \0-terminated. 
  14.     char16_t name[128]; 
  15.  
  16.     // Offset to a ResStringPool_header defining the resource 
  17.     // type symbol table.  If zero, this package is inheriting from 
  18.     // another base package (overriding specific values in it). 
  19.     uint32_t typeStrings; 
  20.  
  21.     // Last index into typeStrings that is for public use by others. 
  22.     uint32_t lastPublicType; 
  23.  
  24.     // Offset to a ResStringPool_header defining the resource 
  25.     // key symbol table.  If zero, this package is inheriting from 
  26.     // another base package (overriding specific values in it). 
  27.     uint32_t keyStrings; 
  28.  
  29.     // Last index into keyStrings that is for public use by others. 
  30.     uint32_t lastPublicKey; 
  31. }; 
  32.  * @author i 
  33.  * 
  34.  */  
  35. public class ResTablePackage {  
  36.       
  37.     public ResChunkHeader header;  
  38.     public int id;  
  39.     public char[] name = new char[128];  
  40.     public int typeStrings;  
  41.     public int lastPublicType;  
  42.     public int keyStrings;  
  43.     public int lastPublicKey;  
  44.       
  45.     public ResTablePackage(){  
  46.         header = new ResChunkHeader();  
  47.     }  
  48.       
  49.     @Override  
  50.     public String toString(){  
  51.         return "header:"+header.toString()+"\n"+",id="+id+",name:"+name.toString()+",typeStrings:"+typeStrings+",lastPublicType:"+lastPublicType+",keyStrings:"+keyStrings+",lastPublicKey:"+lastPublicKey;  
  52.     }  
  53.   
  54. }  
header：Chunk的头部信息数据结构

id：包的ID,等于Package Id,一般用户包的值Package Id为0X7F,系统资源包的Package Id为0X01；这个值很重要的，在后面我们构建前面说到的那个public.xml中的id值的时候需要用到。

name：包名

typeString：类型字符串资源池相对头部的偏移

lastPublicType：最后一个导出的Public类型字符串在类型字符串资源池中的索引，目前这个值设置为类型字符串资源池的元素个数。在解析的过程中没发现他的用途

keyStrings：资源项名称字符串相对头部的偏移

lastPublicKey：最后一个导出的Public资源项名称字符串在资源项名称字符串资源池中的索引，目前这个值设置为资源项名称字符串资源池的元素个数。在解析的过程中没发现他的用途


实例：


图中紫色高亮的部分就是ResTable_package,按照上面的格式解析数据,我们可以得出,此Chunk的Type为RES_TABLE_PACKAGE_TYPE,头部大小为0X120,整个chunk的大小为1030716byte,Package Id为0X7F,包名称为co.runner.app,类型字符串资源池距离头部的偏移是0X120,有15条字符串,资源项名称字符串资源池0X1EC,有6249条字符串。
Packege数据块的整体结构,可以用以下的示意图表示：


其中Type String Pool和Key String Pool是两个字符串资源池,结构和资源项的值字符串资源池结构相同,分别对应类型字符串资源池和资源项名称字符串资源池。
再接下来的结构体可能是类型规范数据块或者类型资源项数据块,我们可以通过他们的Type来识别,类型规范数据块的Type为RES_TABLE_TYPE_SPEC_TYPE,类型资源项数据块的Type为RES_TABLE_TYPE_TYPE。


第五、类型规范数据块

类型规范数据块用来描述资源项的配置差异性。通过这个差异性描述，我们就可以知道每一个资源项的配置状况。知道了一个资源项的配置状况之后，Android资源管理框架在检测到设备的配置信息发生变化之后，就可以知道是否需要重新加载该资源项。类型规范数据块是按照类型来组织的，也就是说，每一种类型都对应有一个类型规范数据块。其数据块头部结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_typeSpec 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     // The type identifier this chunk is holding.  Type IDs start 
  9.     // at 1 (corresponding to the value of the type bits in a 
  10.     // resource identifier).  0 is invalid. 
  11.     uint8_t id; 
  12.      
  13.     // Must be 0. 
  14.     uint8_t res0; 
  15.     // Must be 0. 
  16.     uint16_t res1; 
  17.      
  18.     // Number of uint32_t entry configuration masks that follow. 
  19.     uint32_t entryCount; 
  20.  
  21.     enum { 
  22.         // Additional flag indicating an entry is public. 
  23.         SPEC_PUBLIC = 0x40000000 
  24.     }; 
  25. }; 
  26.  * @author i 
  27.  * 
  28.  */  
  29. public class ResTableTypeSpec {  
  30.       
  31.     public final static int SPEC_PUBLIC = 0x40000000;  
  32.       
  33.     public ResChunkHeader header;  
  34.     public byte id;  
  35.     public byte res0;  
  36.     public short res1;  
  37.     public int entryCount;  
  38.       
  39.     public ResTableTypeSpec(){  
  40.         header = new ResChunkHeader();  
  41.     }  
  42.       
  43.     @Override  
  44.     public String toString(){  
  45.         return "header:"+header.toString()+",id:"+id+",res0:"+res0+",res1:"+res1+",entryCount:"+entryCount;  
  46.     }  
  47.       
  48. }  
header：Chunk的头部信息结构

id：标识资源的Type ID,Type ID是指资源的类型ID。资源的类型有animator、anim、color、drawable、layout、menu、raw、string和xml等等若干种，每一种都会被赋予一个ID。

res0：保留,始终为0

res1：保留,始终为0

entryCount：等于本类型的资源项个数,指名称相同的资源项的个数。


实例：


图中绿色高亮的部分就是ResTable_typeSpec,按照上面的格式解析数据,我们可以得出,此Chunk的Type为RES_TABLE_TYPE_SPEC_TYPE,头部大小为0X10,整个chunk的大小为564byte,资源ID为1,本类型资源项数量为137。
ResTable_typeSpec后面紧跟着的是一个大小为entryCount的uint32_t数组，每一个数组元素都用来描述一个资源项的配置差异性的。


第六、资源类型项数据块

类型资源项数据块用来描述资源项的具体信息, 这样我们就可以知道每一个资源项的名称、值和配置等信息。 类型资源项数据同样是按照类型和配置来组织的,也就是说,一个具有n个配置的类型一共对应有n个类型资源项数据块。其数据块头部结构如下

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4. struct ResTable_type 
  5. { 
  6.     struct ResChunk_header header; 
  7.  
  8.     enum { 
  9.         NO_ENTRY = 0xFFFFFFFF 
  10.     }; 
  11.      
  12.     // The type identifier this chunk is holding.  Type IDs start 
  13.     // at 1 (corresponding to the value of the type bits in a 
  14.     // resource identifier).  0 is invalid. 
  15.     uint8_t id; 
  16.      
  17.     // Must be 0. 
  18.     uint8_t res0; 
  19.     // Must be 0. 
  20.     uint16_t res1; 
  21.      
  22.     // Number of uint32_t entry indices that follow. 
  23.     uint32_t entryCount; 
  24.  
  25.     // Offset from header where ResTable_entry data starts. 
  26.     uint32_t entriesStart; 
  27.      
  28.     // Configuration this collection of entries is designed for. 
  29.     ResTable_config config; 
  30. }; 
  31.  * @author i 
  32.  * 
  33.  */  
  34. public class ResTableType {  
  35.       
  36.     public ResChunkHeader header;  
  37.       
  38.     public final static int NO_ENTRY = 0xFFFFFFFF;  
  39.       
  40.     public byte id;  
  41.     public byte res0;  
  42.     public short res1;  
  43.     public int entryCount;  
  44.     public int entriesStart;  
  45.       
  46.     public ResTableConfig resConfig;  
  47.       
  48.     public ResTableType(){  
  49.         header = new ResChunkHeader();  
  50.         resConfig = new ResTableConfig();  
  51.     }  
  52.   
  53.     public int getSize(){  
  54.         return header.getHeaderSize() + 1 + 1 + 2 + 4 + 4;  
  55.     }  
  56.       
  57.     @Override  
  58.     public String toString(){  
  59.         return "header:"+header.toString()+",id:"+id+",res0:"+res0+",res1:"+res1+",entryCount:"+entryCount+",entriesStart:"+entriesStart;  
  60.     }  
  61.   
  62. }  
header：Chunk的头部信息结构

id：标识资源的Type ID

res0：保留,始终为0

res1：保留,始终为0

entryCount：等于本类型的资源项个数,指名称相同的资源项的个数。

entriesStart：等于资源项数据块相对头部的偏移值。

resConfig：指向一个ResTable_config,用来描述配置信息,地区,语言,分辨率等

实例：


图中红色高亮的部分就是ResTable_type,按照上面的格式解析数据,我们可以得出,RES_TABLE_TYPE_TYPE,头部大小为0X44,整个chunk的大小为4086byte,资源ID为1,本类型资源项数量为137,资源数据块相对于头部的偏移为0X268。
ResTable_type后接着是一个大小为entryCount的uint32_t数组，每一个数组元素都用来描述一个资源项数据块的偏移位置。 紧跟在这个偏移数组后面的是一个大小为entryCount的ResTable_entry数组,每一个数组元素都用来描述一个资源项的具体信息。ResTable_entry的结构如下：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.ParseResourceUtils;  
  4.   
  5. /** 
  6. struct ResTable_entry 
  7. { 
  8.     // Number of bytes in this structure. 
  9.     uint16_t size; 
  10.  
  11.     enum { 
  12.         // If set, this is a complex entry, holding a set of name/value 
  13.         // mappings.  It is followed by an array of ResTable_map structures. 
  14.         FLAG_COMPLEX = 0x0001, 
  15.         // If set, this resource has been declared public, so libraries 
  16.         // are allowed to reference it. 
  17.         FLAG_PUBLIC = 0x0002 
  18.     }; 
  19.     uint16_t flags; 
  20.      
  21.     // Reference into ResTable_package::keyStrings identifying this entry. 
  22.     struct ResStringPool_ref key; 
  23. }; 
  24.  * @author i 
  25.  * 
  26.  */  
  27. public class ResTableEntry {  
  28.       
  29.     public final static int FLAG_COMPLEX = 0x0001;  
  30.     public final static int FLAG_PUBLIC = 0x0002;  
  31.       
  32.     public short size;  
  33.     public short flags;  
  34.       
  35.     public ResStringPoolRef key;  
  36.       
  37.     public ResTableEntry(){  
  38.         key = new ResStringPoolRef();  
  39.     }  
  40.       
  41.     public int getSize(){  
  42.         return 2+2+key.getSize();  
  43.     }  
  44.       
  45.     @Override  
  46.     public String toString(){  
  47.         return "size:"+size+",flags:"+flags+",key:"+key.toString()+",str:"+ParseResourceUtils.getKeyString(key.index);  
  48.     }  
  49.   
  50. }  
ResTable_entry根据flags的不同,后面跟随的数据也不相同,如果flags此位为1,则ResTable_entry是ResTable_map_entry,ResTable_map_entry继承自ResTable_entry,其结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResTable_map_entry : public ResTable_entry 
  5.  { 
  6.      //指向父ResTable_map_entry的资源ID，如果没有父ResTable_map_entry，则等于0。 
  7.      ResTable_ref parent; 
  8.      //等于后面ResTable_map的数量 
  9.      uint32_t count; 
  10.  }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableMapEntry extends ResTableEntry{  
  15.       
  16.     public ResTableRef parent;  
  17.     public int count;  
  18.       
  19.     public ResTableMapEntry(){  
  20.         parent = new ResTableRef();  
  21.     }  
  22.       
  23.     @Override  
  24.     public int getSize(){  
  25.         return super.getSize() + parent.getSize() + 4;  
  26.     }  
  27.       
  28.     @Override  
  29.     public String toString(){  
  30.         return super.toString() + ",parent:"+parent.toString()+",count:"+count;  
  31.     }  
  32.   
  33. }  
ResTable_map_entry其后跟随则count个ResTable_map类型的数组,ResTable_map的结构如下：
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. /** 
  4.  struct ResTable_map 
  5.  { 
  6.      //bag资源项ID 
  7.      ResTable_ref name; 
  8.      //bag资源项值 
  9.      Res_value value; 
  10.  }; 
  11.  * @author i 
  12.  * 
  13.  */  
  14. public class ResTableMap {  
  15.       
  16.     public ResTableRef name;  
  17.     public ResValue value;  
  18.       
  19.     public ResTableMap(){  
  20.         name = new ResTableRef();  
  21.         value = new ResValue();  
  22.     }  
  23.       
  24.     public int getSize(){  
  25.         return name.getSize() + value.getSize();  
  26.     }  
  27.       
  28.     @Override  
  29.     public String toString(){  
  30.         return name.toString()+",value:"+value.toString();  
  31.     }  
  32.   
  33. }  

实例：


图中颜色由深到浅就是一个完整的flags为1的资源项,现在就一起来解读这段数据的含义,这个资源项头部的大小为0X10,flags为1所以后面跟随的是ResTable_map数组,名称没有在资源项引用池中,没有父map_entry,有一个ResTable_map。
如果flags此位为0,则ResTable_entry其后跟随的是一个Res_value,描述一个普通资源的值,Res_value结构如下。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource.type;  
  2.   
  3. import com.wjdiankong.parseresource.ParseResourceUtils;  
  4.   
  5. /** 
  6. struct Res_value 
  7.  { 
  8.      //Res_value头部大小 
  9.      uint16_t size; 
  10.      //保留,始终为0 
  11.      uint8_t res0; 
  12.   
  13.      enum { 
  14.          TYPE_NULL = 0x00, 
  15.          TYPE_REFERENCE = 0x01, 
  16.          TYPE_ATTRIBUTE = 0x02, 
  17.          TYPE_STRING = 0x03, 
  18.          TYPE_FLOAT = 0x04, 
  19.          TYPE_DIMENSION = 0x05, 
  20.          TYPE_FRACTION = 0x06, 
  21.          TYPE_FIRST_INT = 0x10, 
  22.          TYPE_INT_DEC = 0x10, 
  23.          TYPE_INT_HEX = 0x11, 
  24.          TYPE_INT_BOOLEAN = 0x12, 
  25.          TYPE_FIRST_COLOR_INT = 0x1c, 
  26.          TYPE_INT_COLOR_ARGB8 = 0x1c, 
  27.          TYPE_INT_COLOR_ARGB8 = 0x1c, 
  28.          TYPE_INT_COLOR_RGB8 = 0x1d, 
  29.          TYPE_INT_COLOR_ARGB4 = 0x1e, 
  30.          TYPE_INT_COLOR_RGB4 = 0x1f, 
  31.          TYPE_LAST_COLOR_INT = 0x1f, 
  32.          TYPE_LAST_INT = 0x1f 
  33.      }; 
  34.      //数据的类型,可以从上面的枚举类型中获取 
  35.      uint8_t dataType; 
  36.   
  37.      //数据对应的索引 
  38.      uint32_t data; 
  39.  }; 
  40.  * @author i 
  41.  * 
  42.  */  
  43. public class ResValue {  
  44.       
  45.     //dataType字段使用的常量  
  46.     public final static int TYPE_NULL = 0x00;  
  47.     public final static int TYPE_REFERENCE = 0x01;  
  48.     public final static int TYPE_ATTRIBUTE = 0x02;  
  49.     public final static int TYPE_STRING = 0x03;  
  50.     public final static int TYPE_FLOAT = 0x04;  
  51.     public final static int TYPE_DIMENSION = 0x05;  
  52.     public final static int TYPE_FRACTION = 0x06;  
  53.     public final static int TYPE_FIRST_INT = 0x10;  
  54.     public final static int TYPE_INT_DEC = 0x10;  
  55.     public final static int TYPE_INT_HEX = 0x11;  
  56.     public final static int TYPE_INT_BOOLEAN = 0x12;  
  57.     public final static int TYPE_FIRST_COLOR_INT = 0x1c;  
  58.     public final static int TYPE_INT_COLOR_ARGB8 = 0x1c;  
  59.     public final static int TYPE_INT_COLOR_RGB8 = 0x1d;  
  60.     public final static int TYPE_INT_COLOR_ARGB4 = 0x1e;  
  61.     public final static int TYPE_INT_COLOR_RGB4 = 0x1f;  
  62.     public final static int TYPE_LAST_COLOR_INT = 0x1f;  
  63.     public final static int TYPE_LAST_INT = 0x1f;  
  64.       
  65.     public static final int  
  66.     COMPLEX_UNIT_PX         =0,  
  67.     COMPLEX_UNIT_DIP        =1,  
  68.     COMPLEX_UNIT_SP         =2,  
  69.     COMPLEX_UNIT_PT         =3,  
  70.     COMPLEX_UNIT_IN         =4,  
  71.     COMPLEX_UNIT_MM         =5,  
  72.     COMPLEX_UNIT_SHIFT      =0,  
  73.     COMPLEX_UNIT_MASK       =15,  
  74.     COMPLEX_UNIT_FRACTION   =0,  
  75.     COMPLEX_UNIT_FRACTION_PARENT=1,  
  76.     COMPLEX_RADIX_23p0      =0,  
  77.     COMPLEX_RADIX_16p7      =1,  
  78.     COMPLEX_RADIX_8p15      =2,  
  79.     COMPLEX_RADIX_0p23      =3,  
  80.     COMPLEX_RADIX_SHIFT     =4,  
  81.     COMPLEX_RADIX_MASK      =3,  
  82.     COMPLEX_MANTISSA_SHIFT  =8,  
  83.     COMPLEX_MANTISSA_MASK   =0xFFFFFF;  
  84.       
  85.       
  86.     public short size;  
  87.     public byte res0;  
  88.     public byte dataType;  
  89.     public int data;  
  90.       
  91.     public int getSize(){  
  92.         return 2 + 1 + 1 + 4;  
  93.     }  
  94.       
  95.     public String getTypeStr(){  
  96.         switch(dataType){  
  97.             case TYPE_NULL:  
  98.                 return "TYPE_NULL";  
  99.             case TYPE_REFERENCE:  
  100.                 return "TYPE_REFERENCE";  
  101.             case TYPE_ATTRIBUTE:  
  102.                 return "TYPE_ATTRIBUTE";  
  103.             case TYPE_STRING:  
  104.                 return "TYPE_STRING";  
  105.             case TYPE_FLOAT:  
  106.                 return "TYPE_FLOAT";  
  107.             case TYPE_DIMENSION:  
  108.                 return "TYPE_DIMENSION";  
  109.             case TYPE_FRACTION:  
  110.                 return "TYPE_FRACTION";  
  111.             case TYPE_FIRST_INT:  
  112.                 return "TYPE_FIRST_INT";  
  113.             case TYPE_INT_HEX:  
  114.                 return "TYPE_INT_HEX";  
  115.             case TYPE_INT_BOOLEAN:  
  116.                 return "TYPE_INT_BOOLEAN";  
  117.             case TYPE_FIRST_COLOR_INT:  
  118.                 return "TYPE_FIRST_COLOR_INT";  
  119.             case TYPE_INT_COLOR_RGB8:  
  120.                 return "TYPE_INT_COLOR_RGB8";  
  121.             case TYPE_INT_COLOR_ARGB4:  
  122.                 return "TYPE_INT_COLOR_ARGB4";  
  123.             case TYPE_INT_COLOR_RGB4:  
  124.                 return "TYPE_INT_COLOR_RGB4";  
  125.         }  
  126.         return "";  
  127.     }  
  128.       
  129.     /*public String getDataStr(){ 
  130.         if(dataType == TYPE_STRING){ 
  131.             return ParseResourceUtils.getResString(data); 
  132.         }else if(dataType == TYPE_FIRST_COLOR_INT){ 
  133.             return Utils.bytesToHexString(Utils.int2Byte(data)); 
  134.         }else if(dataType == TYPE_INT_BOOLEAN){ 
  135.             return data==0 ? "false" : "true"; 
  136.         } 
  137.         return data+""; 
  138.     }*/  
  139.       
  140.     public String getDataStr() {  
  141.         if (dataType == TYPE_STRING) {  
  142.             return ParseResourceUtils.getResString(data);  
  143.         }  
  144.         if (dataType == TYPE_ATTRIBUTE) {  
  145.             return String.format("?%s%08X",getPackage(data),data);  
  146.         }  
  147.         if (dataType == TYPE_REFERENCE) {  
  148.             return String.format("@%s%08X",getPackage(data),data);  
  149.         }  
  150.         if (dataType == TYPE_FLOAT) {  
  151.             return String.valueOf(Float.intBitsToFloat(data));  
  152.         }  
  153.         if (dataType == TYPE_INT_HEX) {  
  154.             return String.format("0x%08X",data);  
  155.         }  
  156.         if (dataType == TYPE_INT_BOOLEAN) {  
  157.             return data!=0?"true":"false";  
  158.         }  
  159.         if (dataType == TYPE_DIMENSION) {  
  160.             return Float.toString(complexToFloat(data))+  
  161.                 DIMENSION_UNITS[data & COMPLEX_UNIT_MASK];  
  162.         }  
  163.         if (dataType == TYPE_FRACTION) {  
  164.             return Float.toString(complexToFloat(data))+  
  165.                 FRACTION_UNITS[data & COMPLEX_UNIT_MASK];  
  166.         }  
  167.         if (dataType >= TYPE_FIRST_COLOR_INT && dataType <= TYPE_LAST_COLOR_INT) {  
  168.             return String.format("#%08X",data);  
  169.         }  
  170.         if (dataType >= TYPE_FIRST_INT && dataType <= TYPE_LAST_INT) {  
  171.             return String.valueOf(data);  
  172.         }  
  173.         return String.format("<0x%X, type 0x%02X>",data, dataType);  
  174.     }  
  175.       
  176.     private static String getPackage(int id) {  
  177.         if (id>>>24==1) {  
  178.             return "android:";  
  179.         }  
  180.         return "";  
  181.     }  
  182.       
  183.     public static float complexToFloat(int complex) {  
  184.         return (float)(complex & 0xFFFFFF00)*RADIX_MULTS[(complex>>4) & 3];  
  185.     }  
  186.       
  187.     private static final float RADIX_MULTS[]={  
  188.         0.00390625F,3.051758E-005F,1.192093E-007F,4.656613E-010F  
  189.     };  
  190.       
  191.     private static final String DIMENSION_UNITS[]={  
  192.         "px","dip","sp","pt","in","mm","",""  
  193.     };  
  194.       
  195.     private static final String FRACTION_UNITS[]={  
  196.         "%","%p","","","","","",""  
  197.     };  
  198.       
  199.     @Override  
  200.     public String toString(){  
  201.         return "size:"+size+",res0:"+res0+",dataType:"+getTypeStr()+",data:"+getDataStr();  
  202.     }  
  203.   
  204. }  

size：ResValue的头部大小

res0：保留，始终为0

dataType：数据的类型,可以从上面的枚举类型中获取

data：数据对应的索引

这里我们看到了有一个转化的方法，这个我们在解析AndroidManifest文件的时候也用到了这个方法。


实例：

图中画红线的部分就是一个ResTable_entry其后跟随的是一个Res_value的例子,从中我们可以得出以下信息,这个头部大小为8,flags等于0,所以后面跟随的是Res_value,在资源项名称字符串资源池中的索引为150,对应的值是badge_continue_months,Res_value的大小为8,数据的类型是TYPE_STRING,在资源项的值字符串资源池的索引为1912,对应的值是res/drawable-nodpi-v4/badge_continue_months.png。
当我们对arsc的文件格式有了了解过后,我们就可以开始我们的探索之旅了,由于在使用Android studio调试Apktool源码的时候遇到很多障碍,在前辈的指导下才能够顺利进行调试,所以下面简单介绍下设置Android studio调试Apktool源码的方法。




四、解析代码分析

因为篇幅的原因，这里就不把所有的代码都粘贴出来了，后面会列出来代码下载地址

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.wjdiankong.parseresource;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.FileInputStream;  
  5.   
  6. public class ParseResourceMain {  
  7.       
  8.     public static void main(String[] args){  
  9.           
  10.         byte[] srcByte = null;  
  11.         FileInputStream fis = null;  
  12.         ByteArrayOutputStream bos = null;  
  13.         try{  
  14.             fis = new FileInputStream("resource/resources_gdt1.arsc");  
  15.             bos = new ByteArrayOutputStream();  
  16.             byte[] buffer = new byte[1024];  
  17.             int len = 0;  
  18.             while((len=fis.read(buffer)) != -1){  
  19.                 bos.write(buffer, 0, len);  
  20.             }  
  21.             srcByte = bos.toByteArray();  
  22.         }catch(Exception e){  
  23.             System.out.println("read res file error:"+e.toString());  
  24.         }finally{  
  25.             try{  
  26.                 fis.close();  
  27.                 bos.close();  
  28.             }catch(Exception e){  
  29.                 System.out.println("close file error:"+e.toString());  
  30.             }  
  31.         }  
  32.           
  33.         if(srcByte == null){  
  34.             System.out.println("get src error...");  
  35.             return;  
  36.         }  
  37.           
  38.         System.out.println("parse restable header...");  
  39.         ParseResourceUtils.parseResTableHeaderChunk(srcByte);  
  40.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  41.         System.out.println();  
  42.           
  43.         System.out.println("parse resstring pool chunk...");  
  44.         ParseResourceUtils.parseResStringPoolChunk(srcByte);  
  45.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  46.         System.out.println();  
  47.           
  48.         System.out.println("parse package chunk...");  
  49.         ParseResourceUtils.parsePackage(srcByte);  
  50.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  51.         System.out.println();  
  52.           
  53.         System.out.println("parse typestring pool chunk...");  
  54.         ParseResourceUtils.parseTypeStringPoolChunk(srcByte);  
  55.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  56.         System.out.println();  
  57.           
  58.         System.out.println("parse keystring pool chunk...");  
  59.         ParseResourceUtils.parseKeyStringPoolChunk(srcByte);  
  60.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  61.         System.out.println();  
  62.           
  63.         int resCount = 0;  
  64.         while(!ParseResourceUtils.isEnd(srcByte.length)){  
  65.             resCount++;  
  66.             boolean isSpec = ParseResourceUtils.isTypeSpec(srcByte);  
  67.             if(isSpec){  
  68.                 System.out.println("parse restype spec chunk...");  
  69.                 ParseResourceUtils.parseResTypeSpec(srcByte);  
  70.                 System.out.println("++++++++++++++++++++++++++++++++++++++");  
  71.                 System.out.println();  
  72.             }else{  
  73.                 System.out.println("parse restype info chunk...");  
  74.                 ParseResourceUtils.parseResTypeInfo(srcByte);  
  75.                 System.out.println("++++++++++++++++++++++++++++++++++++++");  
  76.                 System.out.println();  
  77.             }  
  78.         }  
  79.         System.out.println("res count:"+resCount);  
  80.           
  81.     }  
  82.   
  83. }  
我们看到代码，首先我们读取resource.arsc文件到一个byte数组，然后开始解析。

第一、解析头部信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析头部信息 
  3.  * @param src 
  4.  */  
  5. public static void parseResTableHeaderChunk(byte[] src){  
  6.     ResTableHeader resTableHeader = new ResTableHeader();  
  7.   
  8.     resTableHeader.header = parseResChunkHeader(src, 0);  
  9.   
  10.     resStringPoolChunkOffset = resTableHeader.header.headerSize;  
  11.   
  12.     //解析PackageCount个数(一个apk可能包含多个Package资源)  
  13.     byte[] packageCountByte = Utils.copyByte(src, resTableHeader.header.getHeaderSize(), 4);  
  14.     resTableHeader.packageCount = Utils.byte2int(packageCountByte);  
  15.   
  16. }  
解析结果：



第二、解析资源字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析Resource.arsc文件中所有字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResStringPoolChunk(byte[] src){  
  6.     ResStringPoolHeader stringPoolHeader = parseStringPoolChunk(src, resStringList, resStringPoolChunkOffset);  
  7.     packageChunkOffset = resStringPoolChunkOffset + stringPoolHeader.header.size;  
  8. }  
这里有一个核心的方法：parseStringPoolChunk

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 统一解析字符串内容 
  3.  * @param src 
  4.  * @param stringList 
  5.  * @param stringOffset 
  6.  * @return 
  7.  */  
  8. public static ResStringPoolHeader parseStringPoolChunk(byte[] src, ArrayList<String> stringList, int stringOffset){  
  9.     ResStringPoolHeader stringPoolHeader = new ResStringPoolHeader();  
  10.   
  11.     //解析头部信息  
  12.     stringPoolHeader.header = parseResChunkHeader(src, stringOffset);  
  13.   
  14.     System.out.println("header size:"+stringPoolHeader.header.headerSize);  
  15.     System.out.println("size:"+stringPoolHeader.header.size);  
  16.   
  17.     int offset = stringOffset + stringPoolHeader.header.getHeaderSize();  
  18.   
  19.     //获取字符串的个数  
  20.     byte[] stringCountByte = Utils.copyByte(src, offset, 4);  
  21.     stringPoolHeader.stringCount = Utils.byte2int(stringCountByte);  
  22.   
  23.     //解析样式的个数  
  24.     byte[] styleCountByte = Utils.copyByte(src, offset+4, 4);  
  25.     stringPoolHeader.styleCount = Utils.byte2int(styleCountByte);  
  26.   
  27.     //这里表示字符串的格式:UTF-8/UTF-16  
  28.     byte[] flagByte = Utils.copyByte(src, offset+8, 4);  
  29.     System.out.println("flag:"+Utils.bytesToHexString(flagByte));  
  30.     stringPoolHeader.flags = Utils.byte2int(flagByte);  
  31.   
  32.     //字符串内容的开始位置  
  33.     byte[] stringStartByte = Utils.copyByte(src, offset+12, 4);  
  34.     stringPoolHeader.stringsStart = Utils.byte2int(stringStartByte);  
  35.     System.out.println("string start:"+Utils.bytesToHexString(stringStartByte));  
  36.   
  37.     //样式内容的开始位置  
  38.     byte[] sytleStartByte = Utils.copyByte(src, offset+16, 4);  
  39.     stringPoolHeader.stylesStart = Utils.byte2int(sytleStartByte);  
  40.     System.out.println("style start:"+Utils.bytesToHexString(sytleStartByte));  
  41.   
  42.     //获取字符串内容的索引数组和样式内容的索引数组  
  43.     int[] stringIndexAry = new int[stringPoolHeader.stringCount];  
  44.     int[] styleIndexAry = new int[stringPoolHeader.styleCount];  
  45.   
  46.     System.out.println("string count:"+stringPoolHeader.stringCount);  
  47.     System.out.println("style count:"+stringPoolHeader.styleCount);  
  48.   
  49.     int stringIndex = offset + 20;  
  50.     for(int i=0;i<stringPoolHeader.stringCount;i++){  
  51.         stringIndexAry[i] = Utils.byte2int(Utils.copyByte(src, stringIndex+i*4, 4));  
  52.     }  
  53.   
  54.     int styleIndex = stringIndex + 4*stringPoolHeader.stringCount;  
  55.     for(int i=0;i<stringPoolHeader.styleCount;i++){  
  56.         styleIndexAry[i] = Utils.byte2int(Utils.copyByte(src,  styleIndex+i*4, 4));  
  57.     }  
  58.   
  59.     //每个字符串的头两个字节的最后一个字节是字符串的长度  
  60.     //这里获取所有字符串的内容  
  61.     int stringContentIndex = styleIndex + stringPoolHeader.styleCount*4;  
  62.     System.out.println("string index:"+Utils.bytesToHexString(Utils.int2Byte(stringContentIndex)));  
  63.     int index = 0;  
  64.     while(index < stringPoolHeader.stringCount){  
  65.         byte[] stringSizeByte = Utils.copyByte(src, stringContentIndex, 2);  
  66.         int stringSize = (stringSizeByte[1] & 0x7F);  
  67.         if(stringSize != 0){  
  68.             String val = "";  
  69.             try{  
  70.                 val = new String(Utils.copyByte(src, stringContentIndex+2, stringSize), "utf-8");  
  71.             }catch(Exception e){  
  72.                 System.out.println("string encode error:"+e.toString());  
  73.             }  
  74.             stringList.add(val);  
  75.         }else{  
  76.             stringList.add("");  
  77.         }  
  78.         stringContentIndex += (stringSize+3);  
  79.         index++;  
  80.     }  
  81.     for(String str : stringList){  
  82.         System.out.println("str:"+str);  
  83.     }  
  84.   
  85.     return stringPoolHeader;  
  86.   
  87. }  
这里在得到一个字符串的时候，需要得到字符串的开始位置和字符串的大小即可，这点和解析AndroidManifest.xml文件中的字符串原理是一样的，就是一个字符串块的头两个字节中的最后一个字节是字符串的长度。这里我们在解析完字符串之后，需要用一个列表将其存储起来，后面有用到，需要通过索引来取字符串内容。

解析结果：



第三、解析包信息

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析Package信息 
  3.  * @param src 
  4.  */  
  5. public static void parsePackage(byte[] src){  
  6.     System.out.println("pchunkoffset:"+Utils.bytesToHexString(Utils.int2Byte(packageChunkOffset)));  
  7.     ResTablePackage resTabPackage = new ResTablePackage();  
  8.     //解析头部信息  
  9.     resTabPackage.header = parseResChunkHeader(src, packageChunkOffset);  
  10.   
  11.     System.out.println("package size:"+resTabPackage.header.headerSize);  
  12.   
  13.     int offset = packageChunkOffset + resTabPackage.header.getHeaderSize();  
  14.   
  15.     //解析packId  
  16.     byte[] idByte = Utils.copyByte(src, offset, 4);  
  17.     resTabPackage.id = Utils.byte2int(idByte);  
  18.     packId = resTabPackage.id;  
  19.   
  20.     //解析包名  
  21.     System.out.println("package offset:"+Utils.bytesToHexString(Utils.int2Byte(offset+4)));  
  22.     byte[] nameByte = Utils.copyByte(src, offset+4, 128*2);//这里的128是这个字段的大小，可以查看类型说明，是char类型的，所以要乘以2  
  23.     String packageName = new String(nameByte);  
  24.     packageName = Utils.filterStringNull(packageName);  
  25.     System.out.println("pkgName:"+packageName);  
  26.   
  27.     //解析类型字符串的偏移值  
  28.     byte[] typeStringsByte = Utils.copyByte(src, offset+4+128*2, 4);  
  29.     resTabPackage.typeStrings = Utils.byte2int(typeStringsByte);  
  30.     System.out.println("typeString:"+resTabPackage.typeStrings);  
  31.   
  32.     //解析lastPublicType字段  
  33.     byte[] lastPublicType = Utils.copyByte(src, offset+8+128*2, 4);  
  34.     resTabPackage.lastPublicType = Utils.byte2int(lastPublicType);  
  35.   
  36.     //解析keyString字符串的偏移值  
  37.     byte[] keyStrings = Utils.copyByte(src, offset+12+128*2, 4);  
  38.     resTabPackage.keyStrings = Utils.byte2int(keyStrings);  
  39.     System.out.println("keyString:"+resTabPackage.keyStrings);  
  40.   
  41.     //解析lastPublicKey  
  42.     byte[] lastPublicKey = Utils.copyByte(src, offset+12+128*2, 4);  
  43.     resTabPackage.lastPublicKey = Utils.byte2int(lastPublicKey);  
  44.   
  45.     //这里获取类型字符串的偏移值和类型字符串的偏移值  
  46.     keyStringPoolChunkOffset = (packageChunkOffset+resTabPackage.keyStrings);  
  47.     typeStringPoolChunkOffset = (packageChunkOffset+resTabPackage.typeStrings);  
  48.   
  49. }  
这里我们看到有一个特殊的地方，就是最后两行，这里需要得到我们后面需要重要解析的两个内容，一个是资源值字符串的偏移值和资源类型字符串的偏移值。

解析结果：



第四、解析资源类型的字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析类型字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseTypeStringPoolChunk(byte[] src){  
  6.     System.out.println("typestring offset:"+Utils.bytesToHexString(Utils.int2Byte(typeStringPoolChunkOffset)));  
  7.     ResStringPoolHeader stringPoolHeader = parseStringPoolChunk(src, typeStringList, typeStringPoolChunkOffset);  
  8.     System.out.println("size:"+stringPoolHeader.header.size);  
  9. }  
这里也是用parseStringPoolChunk方法进行解析的，同样也需要用一个字符串列表存储内容

解析结果：



第五、解析资源值字符串内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析key字符串内容 
  3.  * @param src 
  4.  */  
  5. public static void parseKeyStringPoolChunk(byte[] src){  
  6.     System.out.println("keystring offset:"+Utils.bytesToHexString(Utils.int2Byte(keyStringPoolChunkOffset)));  
  7.     ResStringPoolHeader stringPoolHeader  = parseStringPoolChunk(src, keyStringList, keyStringPoolChunkOffset);  
  8.     System.out.println("size:"+stringPoolHeader.header.size);  
  9.     //解析完key字符串之后，需要赋值给resType的偏移值,后续还需要继续解析  
  10.     resTypeOffset = (keyStringPoolChunkOffset+stringPoolHeader.header.size);  
  11. }  
这里也是一样，使用parseStringPoolChunk方法来解析，解析完之后需要用一个字符串列表保存，后面需要使用索引值来访问

解析结果：



第六、解析正文内容

这里说到的正文内容就是ResValue值，也就是开始构建public.xml中的条目信息，和类型的分离不同的xml文件，所以这部分的内容的解析工作有点复杂

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. int resCount = 0;  
  2. while(!ParseResourceUtils.isEnd(srcByte.length)){  
  3.     resCount++;  
  4.     boolean isSpec = ParseResourceUtils.isTypeSpec(srcByte);  
  5.     if(isSpec){  
  6.         System.out.println("parse restype spec chunk...");  
  7.         ParseResourceUtils.parseResTypeSpec(srcByte);  
  8.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  9.         System.out.println();  
  10.     }else{  
  11.         System.out.println("parse restype info chunk...");  
  12.         ParseResourceUtils.parseResTypeInfo(srcByte);  
  13.         System.out.println("++++++++++++++++++++++++++++++++++++++");  
  14.         System.out.println();  
  15.     }  
  16. }  
  17. System.out.println("res count:"+resCount);  
这里有一个循环解析，有两个方法，一个是isEnd方法，一个是isTypeSpec方法

我们如果仔细看上面的那张神图的话，就可以看到，后面的ResType和ResTypeSpec他们两个内容是交替出现的，直到文件结束。

所以isEnd方法就是判断是否到达文件结束位置：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 判断是否到文件末尾了 
  3.  * @param length 
  4.  * @return 
  5.  */  
  6. public static boolean isEnd(int length){  
  7.     if(resTypeOffset>=length){  
  8.         return true;  
  9.     }  
  10.     return false;  
  11. }  

还有一个方法就是判断是ResType还是ResTypeSpec，这个可以通过Chunk中头部信息来区分的：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 判断是不是类型描述符 
  3.  * @param src 
  4.  * @return 
  5.  */  
  6. public static boolean isTypeSpec(byte[] src){  
  7.     ResChunkHeader header = parseResChunkHeader(src, resTypeOffset);  
  8.     if(header.type == 0x0202){  
  9.         return true;  
  10.     }  
  11.     return false;  
  12. }  
那么就是分别来解析ResTypeSpec和ResType这两个内容了：

1、解析ResTypeSpec

主要得到Res的每个类型名

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析ResTypeSepc类型描述内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResTypeSpec(byte[] src){  
  6.     System.out.println("res type spec offset:"+Utils.bytesToHexString(Utils.int2Byte(resTypeOffset)));  
  7.     ResTableTypeSpec typeSpec = new ResTableTypeSpec();  
  8.     //解析头部信息  
  9.     typeSpec.header = parseResChunkHeader(src, resTypeOffset);  
  10.   
  11.     int offset = (resTypeOffset + typeSpec.header.getHeaderSize());  
  12.   
  13.     //解析id类型  
  14.     byte[] idByte = Utils.copyByte(src, offset, 1);  
  15.     typeSpec.id = (byte)(idByte[0] & 0xFF);  
  16.     resTypeId = typeSpec.id;  
  17.   
  18.     //解析res0字段,这个字段是备用的，始终是0  
  19.     byte[] res0Byte = Utils.copyByte(src, offset+1, 1);  
  20.     typeSpec.res0 = (byte)(res0Byte[0] & 0xFF);  
  21.   
  22.     //解析res1字段，这个字段是备用的，始终是0  
  23.     byte[] res1Byte = Utils.copyByte(src, offset+2, 2);  
  24.     typeSpec.res1 = Utils.byte2Short(res1Byte);  
  25.   
  26.     //entry的总个数  
  27.     byte[] entryCountByte = Utils.copyByte(src, offset+4, 4);  
  28.     typeSpec.entryCount = Utils.byte2int(entryCountByte);  
  29.   
  30.     System.out.println("res type spec:"+typeSpec);  
  31.   
  32.     System.out.println("type_name:"+typeStringList.get(typeSpec.id-1));  
  33.   
  34.     //获取entryCount个int数组  
  35.     int[] intAry = new int[typeSpec.entryCount];  
  36.     int intAryOffset = resTypeOffset + typeSpec.header.headerSize;  
  37.     System.out.print("int element:");  
  38.     for(int i=0;i<typeSpec.entryCount;i++){  
  39.         int element = Utils.byte2int(Utils.copyByte(src, intAryOffset+i*4, 4));  
  40.         intAry[i] = element;  
  41.         System.out.print(element+",");  
  42.     }  
  43.     System.out.println();  
  44.   
  45.     resTypeOffset += typeSpec.header.size;  
  46.   
  47. }  

解析结果：



2、解析ResType

主要得到每个res类型的所有条目内容

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 解析类型信息内容 
  3.  * @param src 
  4.  */  
  5. public static void parseResTypeInfo(byte[] src){  
  6.     System.out.println("type chunk offset:"+Utils.bytesToHexString(Utils.int2Byte(resTypeOffset)));  
  7.     ResTableType type = new ResTableType();  
  8.     //解析头部信息  
  9.     type.header = parseResChunkHeader(src, resTypeOffset);  
  10.   
  11.     int offset = (resTypeOffset + type.header.getHeaderSize());  
  12.   
  13.     //解析type的id值  
  14.     byte[] idByte = Utils.copyByte(src, offset, 1);  
  15.     type.id = (byte)(idByte[0] & 0xFF);  
  16.   
  17.     //解析res0字段的值，备用字段，始终是0  
  18.     byte[] res0 = Utils.copyByte(src, offset+1, 1);  
  19.     type.res0 = (byte)(res0[0] & 0xFF);  
  20.   
  21.     //解析res1字段的值，备用字段，始终是0  
  22.     byte[] res1 = Utils.copyByte(src, offset+2, 2);  
  23.     type.res1 = Utils.byte2Short(res1);  
  24.   
  25.     byte[] entryCountByte = Utils.copyByte(src, offset+4, 4);  
  26.     type.entryCount = Utils.byte2int(entryCountByte);  
  27.   
  28.     byte[] entriesStartByte = Utils.copyByte(src, offset+8, 4);  
  29.     type.entriesStart = Utils.byte2int(entriesStartByte);  
  30.   
  31.     ResTableConfig resConfig = new ResTableConfig();  
  32.     resConfig = parseResTableConfig(Utils.copyByte(src, offset+12, resConfig.getSize()));  
  33.     System.out.println("config:"+resConfig);  
  34.   
  35.     System.out.println("res type info:"+type);  
  36.   
  37.     System.out.println("type_name:"+typeStringList.get(type.id-1));  
  38.   
  39.     //先获取entryCount个int数组  
  40.     System.out.print("type int elements:");  
  41.     int[] intAry = new int[type.entryCount];  
  42.     for(int i=0;i<type.entryCount;i++){  
  43.         int element = Utils.byte2int(Utils.copyByte(src, resTypeOffset+type.header.headerSize+i*4, 4));  
  44.         intAry[i] = element;  
  45.         System.out.print(element+",");  
  46.     }  
  47.     System.out.println();  
  48.   
  49.     //这里开始解析后面对应的ResEntry和ResValue  
  50.     int entryAryOffset = resTypeOffset + type.entriesStart;  
  51.     ResTableEntry[] tableEntryAry = new ResTableEntry[type.entryCount];  
  52.     ResValue[] resValueAry = new ResValue[type.entryCount];  
  53.     System.out.println("entry offset:"+Utils.bytesToHexString(Utils.int2Byte(entryAryOffset)));  
  54.   
  55.     //这里存在一个问题就是如果是ResMapEntry的话，偏移值是不一样的，所以这里需要计算不同的偏移值  
  56.     int bodySize = 0, valueOffset = entryAryOffset;  
  57.     for(int i=0;i<type.entryCount;i++){  
  58.         int resId = getResId(i);  
  59.         System.out.println("resId:"+Utils.bytesToHexString(Utils.int2Byte(resId)));  
  60.         ResTableEntry entry = new ResTableEntry();  
  61.         ResValue value = new ResValue();  
  62.         valueOffset += bodySize;  
  63.         System.out.println("valueOffset:"+Utils.bytesToHexString(Utils.int2Byte(valueOffset)));  
  64.         entry = parseResEntry(Utils.copyByte(src, valueOffset, entry.getSize()));  
  65.   
  66.         //这里需要注意的是，先判断entry的flag变量是否为1,如果为1的话，那就ResTable_map_entry  
  67.         if(entry.flags == 1){  
  68.             //这里是复杂类型的value  
  69.             ResTableMapEntry mapEntry = new ResTableMapEntry();  
  70.             mapEntry = parseResMapEntry(Utils.copyByte(src, valueOffset, mapEntry.getSize()));  
  71.             System.out.println("map entry:"+mapEntry);  
  72.             ResTableMap resMap = new ResTableMap();  
  73.             for(int j=0;j<mapEntry.count;j++){  
  74.                 int mapOffset = valueOffset + mapEntry.getSize() + resMap.getSize()*j;  
  75.                 resMap = parseResTableMap(Utils.copyByte(src, mapOffset, resMap.getSize()));  
  76.                 System.out.println("map:"+resMap);  
  77.             }  
  78.             bodySize = mapEntry.getSize() + resMap.getSize()*mapEntry.count;  
  79.         }else{  
  80.             System.out.println("entry:"+entry);  
  81.             //这里是简单的类型的value  
  82.             value = parseResValue(Utils.copyByte(src, valueOffset+entry.getSize(), value.getSize()));  
  83.             System.out.println("value:"+value);  
  84.             bodySize = entry.getSize()+value.getSize();  
  85.         }  
  86.   
  87.         tableEntryAry[i] = entry;  
  88.         resValueAry[i] = value;  
  89.   
  90.         System.out.println("======================================");  
  91.     }  
  92.   
  93.     resTypeOffset += type.header.size;  
  94.   
  95. }  
  96.   
  97. /** 
  98.  * 解析ResEntry内容 
  99.  * @param src 
  100.  * @return 
  101.  */  
  102. public static ResTableEntry parseResEntry(byte[] src){  
  103.     ResTableEntry entry = new ResTableEntry();  
  104.   
  105.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  106.     entry.size = Utils.byte2Short(sizeByte);  
  107.   
  108.     byte[] flagByte = Utils.copyByte(src, 2, 2);  
  109.     entry.flags = Utils.byte2Short(flagByte);  
  110.   
  111.     ResStringPoolRef key = new ResStringPoolRef();  
  112.     byte[] keyByte = Utils.copyByte(src, 4, 4);  
  113.     key.index = Utils.byte2int(keyByte);  
  114.     entry.key = key;  
  115.   
  116.     return entry;  
  117. }  
  118.   
  119. /** 
  120.  * 解析ResMapEntry内容 
  121.  * @param src 
  122.  * @return 
  123.  */  
  124. public static ResTableMapEntry parseResMapEntry(byte[] src){  
  125.     ResTableMapEntry entry = new ResTableMapEntry();  
  126.   
  127.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  128.     entry.size = Utils.byte2Short(sizeByte);  
  129.   
  130.     byte[] flagByte = Utils.copyByte(src, 2, 2);  
  131.     entry.flags = Utils.byte2Short(flagByte);  
  132.   
  133.     ResStringPoolRef key = new ResStringPoolRef();  
  134.     byte[] keyByte = Utils.copyByte(src, 4, 4);  
  135.     key.index = Utils.byte2int(keyByte);  
  136.     entry.key = key;  
  137.   
  138.     ResTableRef ref = new ResTableRef();  
  139.     byte[] identByte = Utils.copyByte(src, 8, 4);  
  140.     ref.ident = Utils.byte2int(identByte);  
  141.     entry.parent = ref;  
  142.     byte[] countByte = Utils.copyByte(src, 12, 4);  
  143.     entry.count = Utils.byte2int(countByte);  
  144.   
  145.     return entry;  
  146. }  
  147.   
  148. /** 
  149.  * 解析ResValue内容 
  150.  * @param src 
  151.  * @return 
  152.  */  
  153. public static ResValue parseResValue(byte[] src){  
  154.     ResValue resValue = new ResValue();  
  155.     byte[] sizeByte = Utils.copyByte(src, 0, 2);  
  156.     resValue.size = Utils.byte2Short(sizeByte);  
  157.   
  158.     byte[] res0Byte = Utils.copyByte(src, 2, 1);  
  159.     resValue.res0 = (byte)(res0Byte[0] & 0xFF);  
  160.   
  161.     byte[] dataType = Utils.copyByte(src, 3, 1);  
  162.     resValue.dataType = (byte)(dataType[0] & 0xFF);  
  163.   
  164.     byte[] data = Utils.copyByte(src, 4, 4);  
  165.     resValue.data = Utils.byte2int(data);  
  166.   
  167.     return resValue;  
  168. }  
  169.   
  170. /** 
  171.  * 解析ResTableMap内容 
  172.  * @param src 
  173.  * @return 
  174.  */  
  175. public static ResTableMap parseResTableMap(byte[] src){  
  176.     ResTableMap tableMap = new ResTableMap();  
  177.   
  178.     ResTableRef ref = new ResTableRef();  
  179.     byte[] identByte = Utils.copyByte(src, 0, ref.getSize());  
  180.     ref.ident = Utils.byte2int(identByte);  
  181.     tableMap.name = ref;  
  182.   
  183.     ResValue value = new ResValue();  
  184.     value = parseResValue(Utils.copyByte(src, ref.getSize(), value.getSize()));  
  185.     tableMap.value = value;  
  186.   
  187.     return tableMap;  
  188.   
  189. }  
  190.   
  191. /** 
  192.  * 解析ResTableConfig配置信息 
  193.  * @param src 
  194.  * @return 
  195.  */  
  196. public static ResTableConfig parseResTableConfig(byte[] src){  
  197.     ResTableConfig config = new ResTableConfig();  
  198.   
  199.     byte[] sizeByte = Utils.copyByte(src, 0, 4);  
  200.     config.size = Utils.byte2int(sizeByte);  
  201.   
  202.     //以下结构是Union  
  203.     byte[] mccByte = Utils.copyByte(src, 4, 2);  
  204.     config.mcc = Utils.byte2Short(mccByte);  
  205.     byte[] mncByte = Utils.copyByte(src, 6, 2);  
  206.     config.mnc = Utils.byte2Short(mncByte);  
  207.     byte[] imsiByte = Utils.copyByte(src, 4, 4);  
  208.     config.imsi = Utils.byte2int(imsiByte);  
  209.   
  210.     //以下结构是Union  
  211.     byte[] languageByte = Utils.copyByte(src, 8, 2);  
  212.     config.language = languageByte;  
  213.     byte[] countryByte = Utils.copyByte(src, 10, 2);  
  214.     config.country = countryByte;  
  215.     byte[] localeByte = Utils.copyByte(src, 8, 4);  
  216.     config.locale = Utils.byte2int(localeByte);  
  217.   
  218.     //以下结构是Union  
  219.     byte[] orientationByte = Utils.copyByte(src, 12, 1);  
  220.     config.orientation = orientationByte[0];  
  221.     byte[] touchscreenByte = Utils.copyByte(src, 13, 1);  
  222.     config.touchscreen = touchscreenByte[0];  
  223.     byte[] densityByte = Utils.copyByte(src, 14, 2);  
  224.     config.density = Utils.byte2Short(densityByte);  
  225.     byte[] screenTypeByte = Utils.copyByte(src, 12, 4);  
  226.     config.screenType = Utils.byte2int(screenTypeByte);  
  227.   
  228.     //以下结构是Union  
  229.     byte[] keyboardByte = Utils.copyByte(src, 16, 1);  
  230.     config.keyboard = keyboardByte[0];  
  231.     byte[] navigationByte = Utils.copyByte(src, 17, 1);  
  232.     config.navigation = navigationByte[0];  
  233.     byte[] inputFlagsByte = Utils.copyByte(src, 18, 1);  
  234.     config.inputFlags = inputFlagsByte[0];  
  235.     byte[] inputPad0Byte = Utils.copyByte(src, 19, 1);  
  236.     config.inputPad0 = inputPad0Byte[0];  
  237.     byte[] inputByte = Utils.copyByte(src, 16, 4);  
  238.     config.input = Utils.byte2int(inputByte);  
  239.   
  240.     //以下结构是Union  
  241.     byte[] screenWidthByte = Utils.copyByte(src, 20, 2);  
  242.     config.screenWidth = Utils.byte2Short(screenWidthByte);  
  243.     byte[] screenHeightByte = Utils.copyByte(src, 22, 2);  
  244.     config.screenHeight = Utils.byte2Short(screenHeightByte);  
  245.     byte[] screenSizeByte = Utils.copyByte(src, 20, 4);  
  246.     config.screenSize = Utils.byte2int(screenSizeByte);  
  247.   
  248.     //以下结构是Union  
  249.     byte[] sdVersionByte = Utils.copyByte(src, 24, 2);  
  250.     config.sdVersion = Utils.byte2Short(sdVersionByte);  
  251.     byte[] minorVersionByte = Utils.copyByte(src, 26, 2);  
  252.     config.minorVersion = Utils.byte2Short(minorVersionByte);  
  253.     byte[] versionByte = Utils.copyByte(src, 24, 4);  
  254.     config.version = Utils.byte2int(versionByte);  
  255.   
  256.     //以下结构是Union  
  257.     byte[] screenLayoutByte = Utils.copyByte(src, 28, 1);  
  258.     config.screenLayout = screenLayoutByte[0];  
  259.     byte[] uiModeByte = Utils.copyByte(src, 29, 1);  
  260.     config.uiMode = uiModeByte[0];  
  261.     byte[] smallestScreenWidthDpByte = Utils.copyByte(src, 30, 2);  
  262.     config.smallestScreenWidthDp = Utils.byte2Short(smallestScreenWidthDpByte);  
  263.     byte[] screenConfigByte = Utils.copyByte(src, 28, 4);  
  264.     config.screenConfig = Utils.byte2int(screenConfigByte);  
  265.   
  266.     //以下结构是Union  
  267.     byte[] screenWidthDpByte = Utils.copyByte(src, 32, 2);  
  268.     config.screenWidthDp = Utils.byte2Short(screenWidthDpByte);  
  269.     byte[] screenHeightDpByte = Utils.copyByte(src, 34, 2);  
  270.     config.screenHeightDp = Utils.byte2Short(screenHeightDpByte);  
  271.     byte[] screenSizeDpByte = Utils.copyByte(src, 32, 4);  
  272.     config.screenSizeDp = Utils.byte2int(screenSizeDpByte);  
  273.   
  274.     byte[] localeScriptByte = Utils.copyByte(src, 36, 4);  
  275.     config.localeScript = localeScriptByte;  
  276.   
  277.     byte[] localeVariantByte = Utils.copyByte(src, 40, 8);  
  278.     config.localeVariant = localeVariantByte;  
  279.     return config;  
  280. }  
看到这里，我们发现这里的解析很复杂的，和我们在讲解数据结构的时候那里一样，他需要解析很多内容：

ResValue，ResTableMap，ResTableMapEntry，ResTableEntry，ResConfig

关于每个数据结构如何解析这里就不多说了，就是读取字节即可。这里有一个核心的代码：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. //这里需要注意的是，先判断entry的flag变量是否为1,如果为1的话，那就ResTable_map_entry  
  2. if(entry.flags == 1){  
  3.     //这里是复杂类型的value  
  4.     ResTableMapEntry mapEntry = new ResTableMapEntry();  
  5.     mapEntry = parseResMapEntry(Utils.copyByte(src, valueOffset, mapEntry.getSize()));  
  6.     System.out.println("map entry:"+mapEntry);  
  7.     ResTableMap resMap = new ResTableMap();  
  8.     for(int j=0;j<mapEntry.count;j++){  
  9.         int mapOffset = valueOffset + mapEntry.getSize() + resMap.getSize()*j;  
  10.         resMap = parseResTableMap(Utils.copyByte(src, mapOffset, resMap.getSize()));  
  11.         System.out.println("map:"+resMap);  
  12.     }  
  13.     bodySize = mapEntry.getSize() + resMap.getSize()*mapEntry.count;  
  14. }else{  
  15.     System.out.println("entry:"+entry);  
  16.     //这里是简单的类型的value  
  17.     value = parseResValue(Utils.copyByte(src, valueOffset+entry.getSize(), value.getSize()));  
  18.     System.out.println("value:"+value);  
  19.     bodySize = entry.getSize()+value.getSize();  
  20. }  
判断flag的值，来进行不同的解析操作。这里需要注意这点。

解析结果：



看到解析结果，还是挺欣慰的，因为最难的地方我们解析成功了，而且看到结果我们很激动，就是我们想要的结果，但是这里需要解释的是，有了这些值我们构建public.xml内容和各个类型的xml内容是很简单，当然这里我们去构建了，感兴趣的同学可以去尝试一下。

注意：这里的ResId的构造方法是：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * 获取资源id 
  3.  * 这里高位是packid，中位是restypeid，地位是entryid 
  4.  * @param entryid 
  5.  * @return 
  6.  */  
  7. public static int getResId(int entryid){  
  8.     return (((packId)<<24) | (((resTypeId) & 0xFF)<<16) | (entryid & 0xFFFF));  
  9. }  
这里我们可以看到就是一个int类型的resId，

他的最高两个字节表示packId,系统资源id是：0x01，普通应用资源id是：0x7F

他的中间的两个字节表示resTypeId，类型id,这个值从0开始，比如我们例子中第一个类型是attr，那么他的resTypeId就是00

他的最低四个字节表示这个资源的顺序id，从1开始，逐渐累加1


项目下载地址：https://github.com/fourbrother/parse_androidarsc


五、技术概述

上面我们就很蛋疼的解析完了所有的resource.arsc文件，当然内容有点多，所以有些地方可能没介绍清楚或者是有错误的地方，请多指正。当然关于Android编译之后的四个文件格式，我们已经介绍了三个了：

so文件格式、AndroidManifest.xml格式/资源文件.xml、resource.arsc

那么剩下就只有classes.dex这一个文件格式了，我们就算大功告成了。但是我想在这里说的是，这篇文章我们主要是介绍解析resource.arsc文件格式，那么写这篇文章的目的是什么呢？

有两个：

1、我们在使用apktool工具进行反编译的时候，经常出现一些莫名的一场信息，最多的就是NotFound ResId 0x0000XXX这些内容，那么这时候我们就可以去修复了，当然我们可以得到apktool的源码来解决这个问题，还可以就是使用我们自己写的这套解析代码也是可以的。

2、我们之前提过，解析resource.arsc文件之后，对resource.arsc文件格式如果有了解了之后，可以对资源文件名进行混淆，从而来减小apk包大小，我在之前的一篇文章：

Apk的签名机制：http://blog.csdn.net/jiangwei0910410003/article/details/50402000

因为META-INF文件夹下的三个文件大小很大，原因就是他们内部保存了每个资源名称，我们在项目中有时候为了不造成冲突，就把资源名起的很长，那么这样就会导致apk的包很大。

同样resource.arsc文件也会很大，因为资源名都是需要保存的，但是我们知道Android中的混淆是不会对资源文件进行混淆的，所以这时候我们就可以通过这个思路来减小包apk的大小了。这个后续我会继续讲解的。


注意：

到这里我们还需要告诉一件事，那就是其实我们上面的解析工作，有一个更简单的方法就可以搞定了？那就是aapt命令？关于这个aapt是干啥的？网上有很多资料，他其实很简单就是将Android中的资源文件打包成resource.arsc即可:


只有那些类型为res/animator、res/anim、res/color、res/drawable（非Bitmap文件，即非.png、.9.png、.jpg、.gif文件）、res/layout、res/menu、res/values和res/xml的资源文件均会从文本格式的XML文件编译成二进制格式的XML文件
这些XML资源文件之所要从文本格式编译成二进制格式，是因为：
1. 二进制格式的XML文件占用空间更小。这是由于所有XML元素的标签、属性名称、属性值和内容所涉及到的字符串都会被统一收集到一个字符串资源池中去，并且会去重。有了这个字符串资源池，原来使用字符串的地方就会被替换成一个索引到字符串资源池的整数值，从而可以减少文件的大小。
2. 二进制格式的XML文件解析速度更快。这是由于二进制格式的XML元素里面不再包含有字符串值，因此就避免了进行字符串解析，从而提高速度。
将XML资源文件从文本格式编译成二进制格式解决了空间占用以及解析效率的问题，但是对于Android资源管理框架来说，这只是完成了其中的一部分工作。Android资源管理框架的另外一个重要任务就是要根据资源ID来快速找到对应的资源。

那么下面我们用aapt命令就可以查看一下？

aapt命令在我们的AndroidSdk目录中：


看到路径了：Android-SDK目录/build-tools/下面

我们也就知道了，这个目录下全是Android中build成一个apk的所有工具，这里再看一下这些工具的用途：


1、使用Android SDK提供的aapt.exe生成R.Java类文件
2、使用Android SDK提供的aidl.exe把.aidl转成.java文件（如果没有aidl，则跳过这一步）
3、使用JDK提供的javac.exe编译.java类文件生成class文件
4、使用Android SDK提供的dx.bat命令行脚本生成classes.dex文件
5、使用Android SDK提供的aapt.exe生成资源包文件（包括res、assets、androidmanifest.xml等）
6、使用Android SDK提供的apkbuilder.bat生成未签名的apk安装文件
7、使用jdk的jarsigner.exe对未签名的包进行apk签名

看到了吧。我们原来可以不借助任何IDE工具，也是可以出一个apk包的。哈哈~~

继续看aapt命令的用法，命令很简单：

aapt l -a apk名称 > demo.txt

将输入的结果定向到demo.txt中


看到我们弄出来的内容，发现就是我们上面解析的AndroidManifest.xml内容，所以这个也是一个方法，当然aapt命令这里我为什么最后说呢？之前我们讲解的AndroidManifest.xml格式肯定是有用的，aapt命令只是系统提供给我们一个很好的工具，我们可以在反编译的过程中借助这个工具也是不错的选择。所以这里我就想说，以后我们记得有一个aapt命令就好了，他的用途还是很多的，可以单独编译成一个resource.arsc文件来，我们后面会用到这个命令。


六、总结

这篇文章篇幅有点长，所以我写的很蛋疼，但是得耐心的看，因为resource.arsc文件格式比AndroidManifest.xml文件格式复杂得多，所以解析起来很费劲的。也希望你们看完之后能多多支持，后面还有一篇解析classes.dex文件格式，当然这篇文章要等年后来才能动笔了，所以尽请期待，最好注大家新年快乐~~


PS: 关注微信，最新Android技术实时推送


jemenchen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手把手教你解析Resources.arsc
beyond702的专栏
06-23 6万+
对于APK里面的Resources.arsc文件大家应该都知道是干什么的（不知道的请看我的另一篇文章Android应用程序资源文件的编译和打包原理），它实际上就是App的资源索引表。下面我会结合实例对它的格式做一下剖析，读完这篇文章应该能够知道Resources.arsc的格式，并可以从二进制的文件中查找到资源的相关信息，或者根据资源的id可以定位到二进制文件中的位置。不过本人对Android资源
一文读懂resource.arsc文件结构
袋鼠
10-05 7305
resource.arsc文件结构概述arsc文件作用chunkarsc文件结构Chunk头结构ResTable_headerStringPoolPackage`ResTable_typeSpec` 和 `ResTable_type`结尾推荐阅读 概述     resource.arsc文件是Apk打包过程中的产生的一个资源索引文件。在对apk进行解压或者使用Android Studio对apk进行分析时便可以看到resource.arsc文件。  &nbs
resources.arsc
04-02
resources.arsc
APK XML解析及反编译之resources.arsc
04-26
完整Android资源resources.arsc文件分析
ArscDecoder:解码Android resources.arsc 文件
07-06
解码器 解码Android resources.arsc 文件 结构体： 共同结构 // 出现在资源中每个数据块前面的标题。 ResChunk_header short type short headerSize int bodySize chunk size: 2 + 2 + 4; 独特的结构 // 资源表的标题。 ResTable_header ResChunk_header header int packageCount chunk size: ResChunk_header.size + 4; // 定义字符串池。 ResStringPool_header ResChunk_header header int stringCount int styleCount int flags int stringsStart
ArscBlamer是一个命令行工具，可以解析Android应用程序的resources.arsc文件并提取有关其内容的有用且可操作的信息-Android开发
05-26
ArscBlamer ArscBlamer是一个命令行工具，可以解析Android应用程序的resources.arsc文件，并提取有关其内容的有用且可操作的信息。 功能包括：输出所有资源配置，并查看典型的ArscBlamer ArscBlamer是一个命令行工具，可以解析Android应用程序的resources.arsc文件并提取有关其内容的有用且可操作的信息。 功能包括：输出所有资源配置，并查看该配置中的类型，变体，大小，空条目，条目计数，密度和（可选）资源名称。 在resources.arsc中输出所有资源名称，并查看其私有，共享和成比例的大小以及它们所属的配置。 输出资源
apktool反编译资源分析
woai110120130的专栏
03-30 1407
前边分析的理解Android资源索引一文分析了resource.arsc的基本格式,我们简单的回顾一下
android apk resources.arsc,可能是全网讲最细的安卓resources.arsc解析教程(一)
weixin_29037455的博客
05-28 2358
aapt工具在编译资源会将一些资源或者资源索引打包成resources.arsc。这个文件以二进制数据的形式记录数据，c/c++加载起来特别方便。了解resources.arsc的结构对理解安卓的资源加载原理有很重要的帮助。这几天写resources.arsc解析工具时候在网上搜到了不少的资料、博客，但是它们写的都不是特别的详细，都会漏掉一些东西没有提。导致在实现的时候遇到了很多的坑。这里我希望尽...
Android资源管理框架-------之resources.arsc（三）
大勇的专栏
09-09 2781
        上一篇我们介绍了Android中资源包相关的东西以及Framework是怎么一步步加载system和应用的资源包的，但是我们的介绍到java层的AssetManager就中止了，没有继续深入，原因是继续深入的话，主要就涉及到ResTable相关的东西了，而ResTable对Android资源的管理，非常...
Android资源索引--resources.arsc
woai110120130的专栏
03-26 2695
今天来介绍下resource.arsc的格式：
arsc:解析Android resources.arsc 文件的工具
06-21
动脉粥样硬化 用于解析 Android resources.arsc 文件的工具。
Android Targeting R+ requires the resources.arsc of installed APKs to be stored uncompressed and al)
最新发布
liuyuqi2020的博客
01-10 887
v1-signing-enabled：是否开启v1签名，值为<true | false>，该工具会使用 --min-sdk-version 和 --max-sdk-version 的值来决定何时采用此签名方案。–v2-signing-enabled：是否开启v2签名，值为<true | false>该工具会使用 --min-sdk-version 和 --max-sdk-version 的值来决定何时采用此签名方案。（–key --cert 签名方式使用该种方式签名才需要,pass:123456）
【Android 安装包优化】资源打包配置 ( resources.arsc 资源映射表 | 配置国际化资源 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-10 3030
一、resources.arsc 资源映射表、 二、配置国际化资源、 三、完整 build.gradle 构建脚本示例、 四、参考资料、
Android6.0之App中的资源Rsources.arsc详解
Java和Android架构
08-07 1806
Apk中的resources.arsc是aapt工具编译资源时生成的一个重要文件。App资源能根据配置的变化，索引到相应的资源都要依赖它。例如Android设备语言，屏幕设备尺寸不同时，app通过同样的ID但却能找到不同的资源进行显示。 资源打包过程简述 开发app时，需要代码和资源。最终生成的apk中代码转换为了dex文件，那么apk文件中的资源是否还是app开发时那些资源文件呢？或者说这些...
第四章 常见的 Android 文件格式（四）（resources.arsc）
zlmm741的博客
03-07 2057
文章目录resources.arscARSC 文件格式ARSC 文件的修改 resources.arsc Android 软件开发过程中有个重要的目录，即 app 工程下的 java/res 目录。这里存放了软件使用的各种类型的资源文件。这些资源文件在编译成 APK 时会被统一打包存放在 APK 的 res 目录。其中，jpg、png 图片文件按照原样存放，layout、drawbale、col...
【Android 安装包优化】资源混淆 ( resources.arsc 资源映射表文件格式 | 头文件 数据格式 | 全局字符串池 数据格式 | 包数据 数据格式 | 包头 数据格式 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-13 1657
一、resources.arsc 资源映射表文件格式、 二、头文件 数据格式、 三、全局字符串池 数据格式、 四、包数据 数据格式、 1、包头 数据格式、 2、资源类型字符串池 数据格式、 3、资源名称字符串池 数据格式、 五、参考资料、
Apk解析之 —— resource.arsc
Knowledge worth spreading
09-24 1806
本篇解析resource.arsc文件，参考文章：Reference 项目源码：ApkParser arsc文件结构arsc文件的结构图，所有的resource资源类型都定义在AOSP的frameworks\base\include\androidfw\ResourceTypes.h头文件中。一、头部信息Resources.arsc文件格式是由一系列的chunk构成，每一个chunk均包含如下
APP反编译和回编译
jmm18363027827的博客
08-10 1342
坑/逆向/app逆向/AndroidKiller/签名 签名后还是无法安装重新打包的apk::需要先把原版卸载掉，才能安装修改后的apk，因为原版的apk签名无法拿到，原版的apk的签名信息和AndroidKiller回编译出来的apk的签名信息不一样，无法共存。#坑/逆向/app逆向/adb 误删了/data/local/tmp文件夹，新建了一个文件夹，adb push到这个文件夹提示权限不够::新建的文件夹权限发生变化了,参考nexus 5这个目录的权限，改成一样，记得要执行。签名证书的链是否有效。
Failure [-124: Failed parse during installPackag eLI: Targeting R+ (version 30 and above) requires the resources.arsc of installed APKs to be stored uncompressed and aligned on a 4-byte boundary]如何处理
06-13
这个错误是由于您的应用程序的资源文件未正确压缩和对齐而导致的。要解决这个问题，您可以尝试以下几种方法： 1. 在您的应用程序的 build.gradle 文件中添加以下代码： ```groovy android { aaptOptions { noCompress "resources.arsc" } } ``` 这将禁用对 resources.arsc 文件的压缩，从而解决了资源文件未正确压缩的问题。 2. 您可以尝试从 Android Studio 的 "Build" 菜单中选择 "Clean Project"，然后再重新构建您的应用程序。 3. 尝试使用最新版本的 Android Gradle 插件和相关工具，这些版本通常会修复此类问题。您可以在 build.gradle 文件中更新 Gradle 插件和相关工具的版本。 希望这些方法可以帮助您解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值