精华内容
下载资源
问答
  • [2013-11-05 14:22:15 - Dex Loader] Unable ...log已经找不到了,大概的意思和上面这个差不多,这时候一定是jar包有重复了,但是我在工程中找不到重复的jar的引用,所以一直在网上找解决的办法。

    [2013-11-05 14:22:15 - Dex Loader] Unable to execute dex: Multiple dex files defineLcom/mobile/appstore/listjar/sdk/R$anim;

    log已经找不到了,大概的意思和上面这个差不多,这时候一定是jar包有重复了,但是我在工程中找不到重复的jar的引用,所以一直在网上找解决的办法。发现大家都说是jar重复了。所以我又好好看了一次我的工程,我的工程中确实没用重复的jar。但是在bin文件夹下有个jarlist.cac文件这里面有两个jar的引用,删除这个文件就可以了

    展开全文
  • 首先我们要理解这句话的意思:无法执行dex:多个dex文件 然后再看他具体的描叙Multiple dex files define Lcom/hp/hpl/sparta/ParseSource; 几多个定义的Lcom/hp/hpl/sparta/ParseSource dex文件

      这个我在网上搜到看到的答案都是那三种复制来复制去的。可惜对我没用然后我只好自己研究了一下,发现问题很简单:

     1.首先我们要理解这句话的意思:无法执行dex:多个dex文件  然后再看他具体的描叙Multiple dex files define Lcom/hp/hpl/sparta/ParseSource;  几多个定义的Lcom/hp/hpl/sparta/ParseSource dex文件

     2.可以猜测是有多个ParseSoure 文件造成的

     3.点击eclipse上的搜索文件按钮,也就是图片上的第二个按钮,然后输入文件名ParseSoure或者搜索sparta可以发现多个jar(lib文件家中)包中有这个文件  及重复调用了这个文件 将这个jar文件删除掉一个就可以了

    4.clean 一下 重新运行就可以了


     



    展开全文
  • 这种提示的意思是说,引用的文件重复了.在引用json解析库中,clean工程的时候,报错说: Unable to execute dex: Multiple dex files define Lorg/apache/commons/collections/Buffer; Conversion to Dalvik format ...

    这种提示的意思是说,引用的文件重复了.在引用json解析库中,clean工程的时候,报错说:

    Unable to execute dex: Multiple dex files define Lorg/apache/commons/collections/Buffer;

    Conversion to Dalvik format failed: Unable to execute dex: Multiple dex files define Lorg/apache/commons/collections/Buffer;

    后来仔细一看,原来commons-beanutils-1.7.0.jar和commons-collections-3.2.jar中都有org.apache.commons.collections.Buffer.class.

    转载于:https://www.cnblogs.com/listened/p/4263428.html

    展开全文
  • Python3解析dex文件

    2018-10-15 17:48:00
    意思是看得懂的,但自己不能手解析一番总觉得不踏实,所以决定写个程序来解析一番。 本文其实算是姜维的Android逆向之旅---解析编译之后的Dex文件格式的Python实现版。   1.2 dex文件格式说明 类似exe文件是windows...

    一、说明

    1.1 背景说明

    看《加密与解密》的时候反复听说“PE文件格式”,到Android安全兴起就不断听说“dex文件格式”。意思是看得懂的,但自己不能手解析一番总觉得不踏实,所以决定写个程序来解析一番。

    本文其实算是姜维的Android逆向之旅---解析编译之后的Dex文件格式的Python实现版。

     

    1.2 dex文件格式说明

    类似exe文件是windows上的可执行文件,dex文件就是android中的可执行文件;pe格式是exe文件的格式,dex文件格式就是dex文件的格式。下边直接偷两张图过来说明dex文件格式

    dex文件格式概况如下:

    dex文件格式详细版如下:

     

    二、程序代码

    我们这里程序所做的是,从dex文件中读取出其header、string_ids、type_ids、proto_ids、filed_ids、method_ids和class_defs等信息。

    前边header、string_ids、type_ids、proto_ids、filed_ids、method_ids应该都是没问题的,最后的class_defs也应该没问题只是层级太深头脑有些混乱没想好怎么组织打印。

    import binascii
    
    class parse_dex:
        def __init__(self,dex_file):
            # 由于后续各区都需要从header中获取自己的数量和偏移,所以在构造函数中调用它
            self.parse_dex_header()
    
        # 此函数用于解析dex文件头部
        def parse_dex_header(self):
            # 定义header结构,key是头成员名称,value是key的字节长度
            # xxx_ids_off表示xxx_ids_item列表的偏移量,xxx_ids_size表示xxx_ids_item个数
            # xxx_off表示xxx的偏移量,xxx_size表示xxx的字节大小
            self.dex_header_struct = {
                # 魔数
                'magic': 8,
                # 文件校验码 ,使用alder32 算法校验文件除去 maigc ,checksum 外余下的所有文件区域 ,用于检查文件错误 。
                'checksum': 4,
                # 使用 SHA-1 算法 hash 除去 magic ,checksum 和 signature 外余下的所有文件区域 ,用于唯一识别本文件 。
                'signature': 20,
                # Dex 文件的大小 。
                'file_size': 4,
                # header 区域的大小 ,单位 Byte ,一般固定为 0x70 常量 。
                'header_size': 4,
                # 大小端标签 ,标准 .dex 文件格式为 小端 ,此项一般固定为 0x1234 5678 常量 。
                'endian_tag': 4,
                # 链接数据的大小
                'link_size': 4,
                # 链接数据的偏移值
                'link_off': 4,
                # map item 的偏移地址 ,该 item 属于 data 区里的内容 ,值要大于等于 data_off 的大小 。
                'map_off': 4,
                # dex中用到的所有的字符串内容的大小
                'string_ids_size': 4,
                # dex中用到的所有的字符串内容的偏移值
                'string_ids_off': 4,
                # dex中的类型数据结构的大小
                'type_ids_size': 4,
                # dex中的类型数据结构的偏移值
                'type_ids_off': 4,
                # dex中的元数据信息数据结构的大小
                'proto_ids_size': 4,
                # dex中的元数据信息数据结构的偏移值
                'proto_ids_off': 4,
                # dex中的字段信息数据结构的大小
                'field_ids_size': 4,
                # dex中的字段信息数据结构的偏移值
                'field_ids_off': 4,
                # dex中的方法信息数据结构的大小
                'method_ids_size': 4,
                # dex中的方法信息数据结构的偏移值
                'method_ids_off': 4,
                # dex中的类信息数据结构的大小
                'class_defs_size': 4,
                # dex中的类信息数据结构的偏移值
                'class_defs_off': 4,
                # dex中数据区域的结构信息的大小
                'data_size': 4,
                # dex中数据区域的结构信息的偏移值
                'data_off': 4
            }
            # 此变量用于存放读取到的dex头部
            self.dex_header = {}
            # 以二进制形式读取文件
            self.fo = open(dex_file, "rb")
            for k, v in self.dex_header_struct.items():
                # size,表示个数的字段,取其十进制
                if "_size" in k:
                    tmp = self.fo.read(v)
                    tmp = int.from_bytes(tmp, byteorder='little', signed=False)
                    self.dex_header[k] = tmp
                # off,表示文件偏移量的字段,为方便与以十六进制打开文件时相对比,取其十六进制
                # 文件中是小端模式,为方便看我们顺序取反
                elif '_off' in k:
                    tmp = self.fo.read(v)
                    tmp = tmp[::-1]
                    self.dex_header[k] = binascii.b2a_hex(tmp).upper()
                # 其余字段保持原本顺序,直接十六进制转字符串
                else:
                    self.dex_header[k] = binascii.hexlify(self.fo.read(v)).upper()
                    # int.from_bytes(binascii.a2b_hex(dex_header['string_ids_off']),byteorder='big',signed=False)
    
        # 此函数用于读取leb128格式数值
        def read_uleb128(self):
            values = []
            value = int.from_bytes(self.fo.read(1), byteorder='little', signed=False)
            values.append(value)
            while value >= 0x7f:
                value = int.from_bytes(self.fo.read(1), byteorder='little', signed=False)
                values.append(value)
            i = len(values)
            result = 0
            values = values[::-1]
            for value in values:
                i = i-1
                result |= (value&0x7f) << (i*7)
            return result
    
        # 此函数用于解析dex文件中的所有字符串;
        # 由于后边type等都要通过序号来获取字符串,所以独立出parse_string_by_index
        def parse_strings(self):
            # 由于已经_off顺序已取反,所以要指定为大端模式转成整数
            string_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['string_ids_off']), byteorder='big', signed=False)
            string_ids_items = []
            # 读取string_ids_size个字符串item
            for index in range(self.dex_header["string_ids_size"]):
                # string, string_ids_off, string_start_off = self.parse_string_by_index(i)
                # 以”字符串序号-起始地址-结束地址-字符串“格式打印
                # print(f"{i}-{string_ids_off}-{string_start_off}-{string}")
                string_ids_item = self.parse_string_by_index(index)
                string_ids_items.append(string_ids_item)
            for index in range(len(string_ids_items)):
                print(f"{string_ids_items[index]}")
    
    
        # 此函数实现读取指定序号字符串
        def parse_string_by_index(self, descriptor_idx):
            # string_ids_off指向string_ids_item结构
            string_ids_item_struct = {
                # string_ids_item结构中只有string_data_off,其长度为4字节
                'string_data_off': 4,
            }
            # string_data_off指向string_data_item结构
            string_data_item = {
                # 字符串长度,ulb128格式
                'size': '',
                # 字符串值
                'data': '',
            }
    
            string_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['string_ids_off']),byteorder='big',signed=False)
            # 计算指定序号字符串string_ids_item的偏移量
            current_string_ids_off = string_ids_off+descriptor_idx*string_ids_item_struct['string_data_off']
            self.fo.seek(current_string_ids_off)
            # 读取指定序号字符串string_data_item的偏移量
            string_start_off_tmp = self.fo.read(string_ids_item_struct['string_data_off'])
            string_start_off = int.from_bytes(string_start_off_tmp, byteorder='little', signed=False)
            self.fo.seek(string_start_off)
            string_data_item['size'] = self.read_uleb128()
            string_data_item['data'] = self.fo.read(string_data_item['size']).decode()
            return {'index':descriptor_idx,'string_start_off':string_start_off,'string_data_item':string_data_item}
    
        # 此函数实现解析dex文件中的所有类型
        # 由于后边proto等都要通过序号来获取类型,所以独立出parse_type_by_index
        def parse_types(self):
            type_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['type_ids_off']), byteorder='big', signed=False)
            # 从header中读off,转十进制要这样转
            # string_ids_off = int.from_bytes(binascii.a2b_hex(dex_header['string_ids_off']), byteorder='big', signed=False)
            # fo.seek(type_ids_off)
            type_ids_items = []
            for index in range(self.dex_header["type_ids_size"]):
                type_ids_item = self.parse_type_by_index(index)
                type_ids_items.append(type_ids_item)
            for value in type_ids_items:
                print(f'{value}')
    
        # 此函数实现解析指定序号的类形
        def parse_type_by_index(self, type_index):
            type_ids_item_struct = {
                'descriptor_idx': 4
            }
            type_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['type_ids_off']), byteorder='big', signed=False)
            current_type_ids_off = type_ids_off + type_index * type_ids_item_struct['descriptor_idx']
            self.fo.seek(current_type_ids_off)
            # 从文件读转十进制直接这样转
            current_type_descriptor_idx = int.from_bytes(self.fo.read(type_ids_item_struct['descriptor_idx']), byteorder='little', signed=False)
            type_ids_item = self.parse_string_by_index(current_type_descriptor_idx)
            return {'type_index': type_index,'type_ids_item':type_ids_item}
    
        # 此函数实现解析dex文件所有proto
        # 由于后边field等都要通过序号来获取类型,所以独立出get_proto_by_index
        def parse_protos(self):
            proto_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['proto_ids_off']), byteorder='big', signed=False)
            proto_id_items = []
            for index in range(self.dex_header["proto_ids_size"]):
                proto_id_item = self.get_proto_by_index(index)
                proto_id_items.append(proto_id_item)
            for value in proto_id_items:
                print(f'{value}')
    
        # 些函数用于读取参数
        def get_parameter(self,parameters_off,para_size):
            for j in range(para_size):
                self.fo.seek(parameters_off + j * 2)
                type_index = int.from_bytes(self.fo.read(2), byteorder='little', signed=False)
                string, string_off = self.parse_type_by_index(type_index)
                yield string
    
        # 此函数实现读取指定序号proto
        def get_proto_by_index(self,proto_idx):
            proto_id_item_struct = {
                'shorty_idx':4,
                'return_type_idx':4,
                'parameters_off':4,
    
            }
            proto_id_item = {}
            proto_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['proto_ids_off']), byteorder='big', signed=False)
            current_type_ids_off = proto_ids_off + proto_idx * (proto_id_item_struct['shorty_idx']+proto_id_item_struct['return_type_idx']+proto_id_item_struct['parameters_off'])
            self.fo.seek(current_type_ids_off)
            shorty_idx = int.from_bytes(self.fo.read(proto_id_item_struct['shorty_idx']), byteorder='little', signed=False)
            return_type_idx = int.from_bytes(self.fo.read(proto_id_item_struct['return_type_idx']), byteorder='little', signed=False)
            parameters_off = int.from_bytes(self.fo.read(proto_id_item_struct['parameters_off']), byteorder='little', signed=False)
            proto_id_item['shorty_idx'] = self.parse_string_by_index(shorty_idx)
            proto_id_item['return_type_idx'] = self.parse_type_by_index(return_type_idx)
            self.fo.seek(parameters_off)
            para_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            proto_id_item['parameters_off'] = self.get_parameter(parameters_off,para_size)
            return {'proto_idx':proto_idx, 'proto_id_item':proto_id_item}
    
        # 此函数实现解析dex文件所有filed
        def parse_fields(self):
            field_id_item_struct = {
                'class_idx':2,
                'type_idx':2,
                'name_idx':4,
            }
            field_id_item = {}
            field_id_items = []
            field_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['field_ids_off']), byteorder='big', signed=False)
            for i in range(self.dex_header["field_ids_size"]):
                current_type_ids_off = field_ids_off + i * (field_id_item_struct['class_idx']+field_id_item_struct['type_idx']+field_id_item_struct['name_idx'])
                self.fo.seek(current_type_ids_off)
                class_index = int.from_bytes(self.fo.read(field_id_item_struct['class_idx']), byteorder='little', signed=False)
                type_idx = int.from_bytes(self.fo.read(field_id_item_struct['type_idx']), byteorder='little', signed=False)
                name_idx = int.from_bytes(self.fo.read(field_id_item_struct['name_idx']), byteorder='little', signed=False)
                field_id_item['class_idx'] = self.parse_type_by_index(class_index)
                #print(f"{i}-{class_index}-{string_off}-{string}")
                field_id_item['type_idx'] = self.parse_type_by_index(type_idx)
                # print(f"{i}-{type_idx}-{string_off}-{string}")
                field_id_item['name_idx'] = self.parse_string_by_index(type_idx)
                field_id_items.append(field_id_item)
            for value in field_id_items:
                print(f"{value}")
    
        # 此函数实现解析dex文件所有method
        def parse_methods(self):
            method_id_item_struct ={
                'class_idx':2,
                'proto_idx':2,
                'name_idx':4,
            }
            method_id_item = {}
            method_id_items = []
            method_ids_off = int.from_bytes(binascii.a2b_hex(self.dex_header['method_ids_off']), byteorder='big', signed=False)
            for i in range(self.dex_header["field_ids_size"]):
                current_type_ids_off = method_ids_off + i * (method_id_item_struct['class_idx']+method_id_item_struct['proto_idx']+method_id_item_struct['name_idx'])
                self.fo.seek(current_type_ids_off)
                class_idx = int.from_bytes(self.fo.read(method_id_item_struct['class_idx']), byteorder='little', signed=False)
                proto_idx = int.from_bytes(self.fo.read(method_id_item_struct['proto_idx']), byteorder='little', signed=False)
                name_idx = int.from_bytes(self.fo.read(method_id_item_struct['name_idx']), byteorder='little', signed=False)
                method_id_item['class_idx'] = self.parse_type_by_index(class_idx)
                method_id_item['proto_idx'] = self.parse_string_by_index(name_idx)
                method_id_item['name_idx'] = self.get_proto_by_index(proto_idx)
                method_id_items.append(method_id_item)
            for value in method_id_items:
                print(f"{value}")
    
        # 以下函数都用于解析dex文件中的class
        def parse_code_item(self,code_off):
            self.fo.seek(code_off)
            # 本段代码使用到的寄存器数目。
            registers_size = int.from_bytes(self.fo.read(2), byteorder='little', signed=False)
            # method传入参数的数目 。
            ins_size = int.from_bytes(self.fo.read(2), byteorder='little', signed=False)
            # 本段代码调用其它method 时需要的参数个数 。
            outs_size = int.from_bytes(self.fo.read(2), byteorder='little', signed=False)
            #  try_item 结构的个数 。
            tries_size = int.from_bytes(self.fo.read(2), byteorder='little', signed=False)
            # 偏移地址 ,指向本段代码的 debug 信息存放位置 ,是一个 debug_info_item 结构。
            debug_info_off = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            # 指令列表的大小 ,以 16-bit 为单位 。 insns 是 instructions 的缩写 。
            insns_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            # 指令列表
            insns = []
            for i in range(insns_size):
                insns.append(int.from_bytes(self.fo.read(2), byteorder='little', signed=False))
    
    
        def parse_encoded_method(self):
            method_idx_diff = self.read_uleb128()
            access_flags = self.read_uleb128()
            code_off = self.read_uleb128()
    
            return [method_idx_diff,access_flags,code_off]
    
        def parse_encoded_field(self,):
            filed_idx_diff = self.read_uleb128()
            access_flags = self.read_uleb128()
    
            return [filed_idx_diff,access_flags]
    
        def parse_class_data_item(self,class_data_off):
            self.fo.seek(class_data_off)
            static_fields_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            instance_fields_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            direct_methods_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
            virtual_methods_size = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
    
            static_fields = []
            instance_fields = []
            direct_methods = []
            virtual_methods = []
    
            for i in range(1,static_fields_size):
                static_fields.append(self.parse_encoded_field(i))
            for i in range(1,instance_fields_size):
                instance_fields.append(self.parse_encoded_field(i))
            for i in range(1,direct_methods_size):
                direct_methods.append(self.parse_encoded_method(i))
            for i in range(1,virtual_methods_size):
                virtual_methods.append(self.parse_encoded_method(i))
            return [static_fields,instance_fields,direct_methods,virtual_methods]
    
        def parse_class(self):
            self.dex_class_def = {
                'class_idx': 4,
                'access_flags': 4,
                'super_class_idx': 4,
                'interfaces_off': 4,
                'source_file_idx': 4,
                'annotations_off': 4,
                'class_date_off': 4,
                'static_values_off': 4
            }
            class_defs_off = int.from_bytes(binascii.a2b_hex(self.dex_header['class_defs_off']), byteorder='big', signed=False)
            for i in range(self.dex_header["class_defs_size"]):
                current_class_defs_off = class_defs_off + i * 32
                self.fo.seek(current_class_defs_off)
                # 描述具体的class类型,值是type_ids的一个index。值必须是一个class类型,不能是数组类型或者基本类型。
                class_idx = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 描述class的访问类型,诸如public,final,static等。在dex-format.html里“access_flagsDefinitions” 有具体的描述。
                access_flags = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 描述supperclass的类型,值的形式跟class_idx一样 。
                superclass_idx = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 值为偏移地址,指向class的interfaces, 被指向的数据结构为type_list。class若没有interfaces,值为 0。
                interfaces_off = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 表示源代码文件的信息,值是string_ids的一个index。若此项信息缺失,此项值赋值为NO_INDEX=0xffff ffff
                source_file_idx = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 值是一个偏移地址,指向的内容是该class的注释,位置在data区,格式为annotations_direcotry_item。若没有此项内容,值为0 。
                annotions_off = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 值是一个偏移地址,指向的内容是该class的使用到的数据,位置在data区,格式为class_data_item。
                # 若没有此项内容,值为0。该结构里有很多内容,详细描述该class的field,method, method里的执行代码等信息。
                class_data_off = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
                # 值是一个偏移地址,指向data区里的一个列表(list),格式为encoded_array_item。若没有此项内容,值为 0。
                static_value_off = int.from_bytes(self.fo.read(4), byteorder='little', signed=False)
    
                class_data_item_dict = self.parse_class_data_item(class_data_off)
    
        def __del__(self):
            self.fo.close()
    
    if __name__ == "__main__":
        # 措定要解析的dex文件的位置
        dex_file = "classes.dex"
        parse_dex_obj = parse_dex(dex_file)
        parse_dex_obj.parse_strings()
        parse_dex_obj.parse_types()
        parse_dex_obj.parse_protos()
        parse_dex_obj.parse_fields()
        parse_dex_obj.parse_methods()
        parse_dex_obj.parse_class()
        for k, v in parse_dex_obj.dex_header.items():
            print(f"dex_header--{k}: {v}")

     

    参考:

    https://blog.csdn.net/jiangwei0910410003/article/details/50668549

    展开全文
  • 今天搞项目的时候,引入了一个jar包,编译后出现了“Conversion to Dalvik format failed: Unable to execute dex: Multiple dex files define”这种情况, 意思是有包冲突了,有两个jar包冲突了,后面直接删除掉一...
  • 解决ERROR:ANDROID DEX: ...

    2017-10-12 20:28:24
    错误Error:Android Dex: ...分析:上面的异常是什么意思呢? Dex文件的方法数超出上限,那么上限(64k=65535) 解决: 1.Eclipse直接在pro
  • Andorid Unable to execute dex: Multiple dex files define,从字面上猜测,Android 报这个错误的意思是你的某个类重复了。大多数情况下是你jar包被android装载了两次,所以,有许多网友提供的解决方案是删除bin目....
  • 从字面意思理解是你一个应用中,出现了多个Dex文件定义。 以下情况会出现此错误: 1.你项目中可能存在一个apk包,其中包含的文件定义与当前项目相同 2.你项目引入的jar包重复实现了相同的定义。(比如: a.jar...
  • 前两天听说海伯要上dex、defi,开始有点一头雾水,没明白什么意思。以太已经初步实现了其白皮书提到的金融、半金融应用的设想。目前基本可以确认它已是区块链金融的底层公链,那么海伯地图公链搞dex、defi是要做什么...
  • 出现这个问题的原因是包的重复引用,意思就是在你自己的项目中引用了某个包,而被你作为library的项目也引用了同一个包,就会有这个问题。 那如何解决呢,我所知道的是有两种方法: 方法1:按照惯例,直接上...
  • 出现这个问题的原因是包的重复引用,意思就是在你自己的项目中引用了某个包,而被你作为library的项目也引用了同一个包,就会有这个问题。 那如何解决呢,我所知道的是有两种方法: 方法1:按照惯例,直接上图吧,...
  • BankToTheFuture.com的CEO及合伙创始人西蒙·迪克森(Simon Dixon)写过一...Engine直译为“引擎”,DEX全称Decentralized exchange,是去中心化交易场所的意思,Engine.DEX结合的意思象征着Engine系统犹如一个动能引擎.
  • 出现这个问题的原因是包的重复引用,意思就是在你自己的项目中引用了某个包,而被你作为library的项目也引用了同一个包,就会有这个问题。 那如何解决呢,我所知道的是有两种方法: 方法1:按照惯例,直接上图吧,...
  • 随着项目越来越大,需求越来越复杂,要导入的库也随之增加。 这不,刚更新了几个库(有一些库的新版本拆分成了两个 jar ),然后 ...搜索了一下,大概的意思就是:Android 打包的 DEX 过程中, 单个 DEX 文件可被引用
  • 首先还是讲下DEX和ODEX的区别:1、简单来讲,官方的版本就是ODEX化的,现在论坛的除了我发的DEX版本其他的都是ODEX版本。这个ODEX优化是什么意思呢?用大家容易理解的话来说你可以想像一个APK是一个程序压缩包,里面...

空空如也

空空如也

1 2 3 4 5
收藏数 93
精华内容 37
关键字:

dex意思