Android杂记

public void setOnClickListener(@Nullable OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);
        }
        getListenerInfo().mOnClickListener = l;
    }

apktool d[ecode] [OPTS] <file.apk> [<dir>]	       // 反编译 apk 文件命令
apktool b[uild] [OPTS] [<app_path>] [<out_file>]   // 编译 apk 文件命令

javac Main.java

dx --dex --output=Main.dex Main.class

struct DexHeader {
    u1  magic[8];           // 魔数
    u4  checksum;           // adler 校验值
    u1  signature[kSHA1DigestLen]; // sha1 校验值
    u4  fileSize;           // DEX 文件大小
    u4  headerSize;         // DEX 文件头大小
    u4  endianTag;          // 字节序
    u4  linkSize;           // 链接段大小
    u4  linkOff;            // 链接段的偏移量
    u4  mapOff;             // DexMapList 偏移量
    u4  stringIdsSize;      // DexStringId 个数
    u4  stringIdsOff;       // DexStringId 偏移量
    u4  typeIdsSize;        // DexTypeId 个数
    u4  typeIdsOff;         // DexTypeId 偏移量
    u4  protoIdsSize;       // DexProtoId 个数
    u4  protoIdsOff;        // DexProtoId 偏移量
    u4  fieldIdsSize;       // DexFieldId 个数
    u4  fieldIdsOff;        // DexFieldId 偏移量
    u4  methodIdsSize;      // DexMethodId 个数
    u4  methodIdsOff;       // DexMethodId 偏移量
    u4  classDefsSize;      // DexCLassDef 个数
    u4  classDefsOff;       // DexClassDef 偏移量
    u4  dataSize;           // 数据段大小
    u4  dataOff;            // 数据段偏移量
};

struct DexMapList
{
	u4 size;			//DexMapItem 的个数
	DexMapItem list[1];  //DexMapItem 结构数组
}

struct DexMapItem
{
	u2 type;	//kDexType开头的类型
	u2 unused;  //未使用，用于字节对齐
	u4 size;    //指定类型的个数
	u4 offset;  //指定类型数据的文件偏移
}

enum {
    kDexTypeHeaderItem               = 0x0000,
    kDexTypeStringIdItem             = 0x0001,
    kDexTypeTypeIdItem               = 0x0002,
    kDexTypeProtoIdItem              = 0x0003,
    kDexTypeFieldIdItem              = 0x0004,
    kDexTypeMethodIdItem             = 0x0005,
    kDexTypeClassDefItem             = 0x0006,
    kDexTypeMapList                  = 0x1000,
    kDexTypeTypeList                 = 0x1001,
    kDexTypeAnnotationSetRefList     = 0x1002,
    kDexTypeAnnotationSetItem        = 0x1003,
    kDexTypeClassDataItem            = 0x2000,
    kDexTypeCodeItem                 = 0x2001,
    kDexTypeStringDataItem           = 0x2002,
    kDexTypeDebugInfoItem            = 0x2003,
    kDexTypeAnnotationItem           = 0x2004,
    kDexTypeEncodedArrayItem         = 0x2005,
    kDexTypeAnnotationsDirectoryItem = 0x2006,
};
上图中的例子：0x0001---->kDexTypeStringIdItem

struct DexStringId {
    u4 stringDataOff;	//字符串数据偏移
};

private void parseDexString() {
    log("\nparse DexString");
    try {
        int stringIdsSize = dex.getDexHeader().string_ids__size;
        for (int i = 0; i < stringIdsSize; i++) {
            int string_data_off = reader.readInt();
            byte size = dexData[string_data_off]; // 第一个字节表示该字符串的长度，之后是字符串内容
            String string_data = new String(Utils.copy(dexData, string_data_off + 1, size));
            DexString string = new DexString(string_data_off, string_data);
            dexStrings.add(string);
            log("string[%d] data: %s", i, string.string_data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

struct DexTypeId
{
	u4 descriptorIdx;	/指向 DexStringId 列表的索引
}

private void parseDexType() {
    log("\nparse DexTypeId");
    try {
        int typeIdsSize = dex.getDexHeader().type_ids__size;
        for (int i = 0; i < typeIdsSize; i++) {
            int descriptor_idx = reader.readInt();
            DexTypeId dexTypeId = new DexTypeId(descriptor_idx, dexStringIds.get(descriptor_idx).string_data);
            dexTypeIds.add(dexTypeId);
            log("type[%d] data: %s", i, dexTypeId.string_data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

struct DexProtoId 
{
    u4  shortyIdx;          //指向 DexStringId 列表的索引
    u4  returnTypeIdx;      //指向 DexTypeId 列表的索引        
    u4  parametersOff;      //指向 DexTypeList 的偏移
};

struct DexTypeList 
{
    u4  size;               //接下来 DexTypeItem 结构体个数
    DexTypeItem list[1];    //DexTypeItem 结构
};

struct DexTypeItem 
{
    u2  typeIdx;            //指向 DexTypeId 列表的索引
};

private void parseDexProto() 
{
    log("\nparse DexProto");
    try {
        int protoIdsSize = dex.getDexHeader().proto_ids__size;
        for (int i = 0; i < protoIdsSize; i++) {
            int shorty_idx = reader.readInt();
            int return_type_idx = reader.readInt();
            int parameters_off = reader.readInt();

            DexProtoId dexProtoId = new DexProtoId(shorty_idx, return_type_idx, parameters_off);
            log("proto[%d]: %s %s %d", i, dexStringIds.get(shorty_idx).string_data,
                    dexTypeIds.get(return_type_idx).string_data, parameters_off);

            if (parameters_off > 0) {
                parseDexProtoParameters(parameters_off);
            }

            dexProtos.add(dexProtoId);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

struct DexFieldId 
{
    u2  classIdx;           //类的类型，指向 DexTypeId 列表的索引
    u2  typeIdx;            //字段类型，指向 DexTypeId 列表的索引
    u4  nameIdx;            //字段名，指向 DexStringId 列表的索引
};

struct DexMethodId 
{
    u2  classIdx;           /* 类的类型，指向 DexTypeId 列表的索引 */
    u2  protoIdx;           /* 声明类型，指向 DexProtoId 列表的索引 */
    u4  nameIdx;            /* 方法名，指向 DexStringId 列表的索引 */
};

struct DexClassDef 
{
    u4  classIdx;           /* 类的类型，指向 DexTypeId 列表的索引 */
    u4  accessFlags;        /* 访问标志 */	   
    u4  superclassIdx;      /* 父类类型，指向 DexTypeId 列表的索引 */
    u4  interfacesOff;      /* 接口，指向 DexTypeList 的偏移 */
    u4  sourceFileIdx;      /* 源文件名，指向 DexTypeStringId 列表的索引 */
    u4  annotationsOff;     /* 注解，指向 DexAnnotationsDirectoryItem 结构 */
    u4  classDataOff;       /* 指向 DexClassData 结构的偏移 */
    u4  staticValuesOff;    /* 指向 DexEncodedArray 结构的偏移 */
};

struct DexClassData 
{
    DexClassDataHeader header;			// 指定字段与方法的个数
    DexField*          staticFields;	//  静态字段，DexField 结构
    DexField*          instanceFields;	//  实例字段，DexField 结构
    DexMethod*         directMethods;   //  直接方法，DexMethod 结构
    DexMethod*         virtualMethods;  //  虚方法，DexMethod 结构
};

其中的 DexClassDataHeader 结构记录了当前类中字段与方法的数目，在 DexClass.h 文件中声明，声明如下 
struct DexClassDataHeader 
{
    u4 staticFieldsSize;	// 静态字段个数
    u4 instanceFieldsSize;  // 实例字段个数
    u4 directMethodsSize;   // 直接方法个数 
    u4 virtualMethodsSize;  // 虚方法个数
};

Ps：在 DexClass.h 文件中所有结构的 u4 类型都是 uleb128 类型，这是一个可变长度类型，由于大多数情况下这些字段的值可以用小于2个字节的空间来表示，所以采用 uleb128 会节省更多的储存空间

struct DexField {
    u4 fieldIdx;    /* 指向 DexFieldId 的索引 */
    u4 accessFlags;
};

struct DexMethod 
{
    u4 methodIdx;    /* 指向 DexMethodId 的索引 */
    u4 accessFlags;  /* 访问标志 */
    u4 codeOff;      /* 指向 DexCode 结构的偏移 */
};

其中的 codeOff 字段指向了一个 DexCode 结构体，DexCode 结构体描述了方法更详细的信息以及方法中指令的内容，该结构体声明如下
struct DexCode {
    u2  registersSize;  // 使用的寄存器个数
    u2  insSize;        // 参数个数
    u2  outsSize;       // 调用其他方法时使用的寄存器个数
    u2  triesSize;      // try/catch 语句个数
    u4  debugInfoOff;   // 指向调试信息的偏移
    u4  insnsSize;      // 指令集的个数，以2字节为单位
    u2  insns[1];       // 指令集
    /* 2字节空间用于结构体对齐 */  
    /* try_item[triesSize] DexTry 结构 */
    /* Try/Catch 中 handler 的个数 */
    /* catch_handler_item[handlersSize]，DexCatchHandler结构 */
};

.method private packedSwitch(I)Ljava/lang/String;
    .locals 1
    .parameter "i"

    .prologue
    .line 21
    const/4 v0, 0x0

    .line 22
    .local v0, str:Ljava/lang/String;
    packed-switch p1, :pswitch_data_0	# packed-switch 分支，pswitch_data_0 为 case 区域

    .line 36						# default 分支
    const-string v0, "she is a person"

    .line 39
    :goto_0
    return-object v0

    .line 24
    :pswitch_0
    const-string v0, "she is a baby"

    .line 25
    goto :goto_0

    .line 27
    :pswitch_1
    const-string v0, "she is a girl"

    .line 28
    goto :goto_0

    .line 30
    :pswitch_2
    const-string v0, "she is a woman"

    .line 31
    goto :goto_0

    .line 33
    :pswitch_3
    const-string v0, "she is an obasan"

    .line 34
    goto :goto_0

    .line 22
    nop

    :pswitch_data_0
    .packed-switch 0x0	# case 区域，数值起始值为 0
        :pswitch_0	# pswitch_ 后的数值为 case 分支需要判断的值
        :pswitch_1
        :pswitch_2
        :pswitch_3
    .end packed-switch
.end method

struct packed-switch-payload
{
 ushort ident; //值固定为0x100
 ushort size; //case数目
 int first_key; //初始case的值
 int[] targets; //每个case相对switch指令处的偏移
};

:sswitch_data_0
    .sparse-switch
        0x5 -> :sswitch_0	#case 5
        0xf -> :sswitch_1	#case 15(0xf)
        0x23 -> :sswitch_2	#case 35(0x23)
        0x41 -> :sswitch_3	#case 65(0x41)

struct sparse-switch-payload
{
 ushort ident; //值固定为0x0200
 ushort size; //case数目
 int[] keys; //每个case的值，顺序从低到高
 int[] targets; //每个case相对switch指令处的偏移
};

struct DexCode {
    u2  registersSize;  // 使用的寄存器个数
    u2  insSize;        // 参数个数
    u2  outsSize;       // 调用其他方法时使用的寄存器个数
    u2  triesSize;      // try/catch 语句个数
    u4  debugInfoOff;   // 指向调试信息的偏移
    u4  insnsSize;      // 指令集的个数，以2字节为单位
    u2  insns[1];       // 指令集
    /* 2字节空间用于结构体对齐 */  
    /* try_item[triesSize] DexTry 结构 */
    /* Try/Catch 中 handler 的个数 */
    /* catch_handler_item[handlersSize]，DexCatchHandler结构 */
};

private void a()
{
	try
	{
		...
		try
		{
		...
		}catch(xxx){
		...
		}
	}catch(YYY){
	...
	}
}

类名.方法名@方法声明

invoke-super                    {this, c}, <ref ResourceCursorAdapter.swapCursor(ref) imp. @ _def_ResourceCursorAdapter_swapCursor@LL>