APP解析
 
.apk文件改为.zip文件
 解压。
 下载dex2jar软件
 解压下载的文件
 将 APK解压出来的文件夹下的 classes.dex 文件复制到 解压下的dex2jar文件下.
 在dex2jar文件夹目录处输入cmd
 复制“d2j-dex2jar.bat classes.dex” 右键粘贴
 会生成一个.jar文件
 下载jd-gui软件
 解压后打开软件
 拖入.jar文件
 
根据不同的代码写出的软件，文件内容不同。
 
手机端下载MT管理器app
 左上角三条杠-------安装包提取-------定位
 然后点击安装包------查看-----classes.dex---------dex++编辑器打开
 
http://q2.qlogo.cn/headimg_dl?dst_uin=1377351008&spec=100
 获取头像链接

 
dedexer是Android DEX文件反汇编工具，目前网上唯一一个反编译dex文件的反编译工具。如果你用过ant编译java程序，那么编译Dedexer是一件非常简单的工作。
 
该软件要求您的电脑要装有Java环境(进入下载jre.Java环境)才能正常使用
 
dedexer与dexdump相比至少有3个优点
 
一，不需要在android模拟器中运行。
 
二，把dex文件按照java源代码package的目录结构建好了目录，每个class文件对应一个ddx文件。不像dexdump那样把所有的结果都放在一起。
 
三，按照Dedexer作者的说法，可以把 Dedexer作为一个像jasmin那样的反编译引擎，目前好多强大的java反编译工具都是以jasmin作为反编译引擎的。
 
使用指南:
 
为了方便,我把ddx1.5.jar放入system32中,运行CMD.输入如下命令:
 
D:\WINDOWS\system32>java -jar ddx1.5.jar
 
Usage: java -jar ddx.jar -o -D -d 
 
 :指定生成的文件放置的目录
 
 :dex源文件.
 
-D - 指定生成错误信息.
 
-o - 指定生成日志文件(dex.log).
 
运行结果,出现一个使用帮助.仔细阅读后试了下:
 
java -jar ddx.jar -o -D -d 
 
java -jar ddx1.5.jar -o -D -d c:\dex\gen c:\dex\classes.dex
 
示例:
 
D:\WINDOWS\system32>
 
java -jar ddx1.5.jar -o -D -d c:\dex\gen c:\dex\classes.dex
 
Processing com/eoeandroid/market/MarketActivity$2
 
Processing com/eoeandroid/market/MarketActivity$1
 
...
 
运行成功,在gen 目录生成了ddx 文件.用文本编辑器打开,可看到类大致结构.

函数为 
 DexFile_openDexFileNative
 
ClassLinker::OpenDexFilesFromOat 
 1、 FindOpenedOatDexFile 查找缓存中是否存在，checksum为空或者相同 
 2、 CreateOatFileForDexLocation 
 一、生成oat文件 执行execv 调用 dex2oat 生成Oat 会启动进程生成较慢 
 std::string dex2oat(Runtime::Current()->GetCompilerExecutable()); 文件路径待研究 
 execv执行成功就返回成功，不管是不是成功 
 二、OatFile::Open打开，如果失败返回null OatFile* OatFile::Open 
 调用 ElfFile::Open 判断非ELF文件返回NULL
 
3、CreateOatFileForDexLocation 生成失败 调用 DexFile::Open 不生成优化
 
  // Failed, bail.
  if (open_oat_file.get() == nullptr) {
    std::string error_msg;
    // dex2oat was disabled or crashed. Add the dex file in the list of dex_files to make progress.
    DexFile::Open(dex_location, dex_location, &error_msg, dex_files);
    error_msgs->push_back(error_msg);
    return false;
  }
 
经过以上分析 内存打开Dex文件的时候 hook execv 然后失败，防止转换oat成功可以提高首次启动速度，且能 
 正常运行，但是每次的速度是变慢的，DEX加固的时候有的手机会出现卡死的情况(有buggly时才会出现)，暂时 
 不知道原因，待以后研究明白在说明，如果有人知道原因也麻烦告知。 
 后来发现凡是不生成oat都会有一定的概率卡屏，实际上是收到BUS_ADRERR信号，通过调试访问的地址正是dex文件的映射地址，但是内存访问确实没有问题的，因此猜测是虚拟机发出的信号，具体机制还不清楚，又经过测试， Dalvik虚拟机打开dex文件存在同样的问题。待深入研究后才能确定是具体原因。

 
 
我们知道，要读取一个类代码，或读取类里的方法代码，都需要打开Ｄex文件，然后按前面介绍的格式去分析，并且读取出相应的内容，才可以给虚拟机进行解释执行。现在，我们就来学习和分析Ｄex文件的读取相关的代码。如下：
 
 
/*
 
 
*Open the specified file read-only. We memory-map the entire thingand
 
 
*parse the contents.
 
 
*
 
 
*This will be called on non-Zip files, especially during VM startup,so
 
 
*we don't want to be too noisy about certain types of failure. (Do
 
 
*we want a "quiet" flag?)
 
 
*
 
 
*On success, we fill out the contents of "pArchive" andreturn 0.
 
 
*/
 
 
intdexZipOpenArchive(const char* fileName, ZipArchive* pArchive)
 
 
{
 
 
上面这段代码输入文件名称，输出文件内容对象。
 
 

 
 
 
int fd, err;
 
 

 
 
 
LOGV("Opening archive '%s' %p\n",fileName, pArchive);
 
 

 
 
 
memset(pArchive, 0, sizeof(ZipArchive));
 
 
上面这行代码清空Ｄex文件对象。
 
 

 
 
 

 
 
 
fd = open(fileName, O_RDONLY, 0);
 
 
if (fd < 0) {
 
 
err = errno ? errno : -1;
 
 
LOGV("Unable to open '%s': %s\n",fileName, strerror(err));
 
 
return err;
 
 
}
 
 
这段代码调用函数open来打开文件，如果不成功就输出出错提示。
 
 

 
 
 

 
 
 
return dexZipPrepArchive(fd, fileName,pArchive);
 
 
这行代码调用函数dexZipPrepArchive来生成dex文件对象。
 
 

 
 
 
}
 
 

 
 
 
在上面这个函数里，主要输入两个参数：fileName和pArchive。其中fileName是输入要打开的dex文件名称，当然它是包括文件路径的；pArchive是打开这个文件后用来表达dex文件内容的对象。代码具体过程是先调用函数memset来清空pArchive文件对象，然后调用函数open打开文件，把文件句柄传送给函数dexZipPrepArchive进
 
 
行文件分析，并把相应内容设置给文件对象pArchive。
 
 

 
 
 
下面来看一下pArchive对象的结构，如下：
 
 
typedefstruct ZipArchive {
 
 
/* open Zip archive */
 
 
int mFd;
 
 
这个zip文件的文件句柄，也就是上面调用open函数打开成功后句柄。
 
 

 
 
 
/* mapped file */
 
 
MemMapping mMap;
 
 
这个是把zip文件映射到内存，加快文件读取，提高文件读取效率。
 
 

 
 
 

 
 
 
/* number of entries in the Zip archive */
 
 
int mNumEntries;
 
 
这个是保存zip文件的入口。
 
 

 
 
 
/*
 
 
* We know how many entries are in the Ziparchive, so we can have a
 
 
* fixed-size hash table. We probe oncollisions.
 
 
*/
 
 
int mHashTableSize;
 
 
ZipHashEntry* mHashTable;
 
 
这里是通过hash的方法来提高读取文件速度。
 
 

 
 
 
}ZipArchive;
 
 

 
 
 
ZipArchive结构保存zip文件的句柄、文件内容映射内存地址、zip入口个数和入口地址（使用hash表达）。
 
 

 
 
 
这一段代码实现打开Ｄex文件，由于Ｄex文件采用zip压缩，所以需要先从zip文件里解压出来，才可以恢复到Dex原始数据。
 
 
 
  
下面来分析这个函数代码，如下：
 
  
intdexZipPrepArchive(int fd, const char* debugFileName, ZipArchive*pArchive)
 
  
{
 
  
这个函数输入文件句柄、文件名称、压缩文件对象。
 
  

 
 
  
MemMapping map;
 
  
int err;
 
  

 
 
  
map.addr = NULL;
 
  
memset(pArchive, 0, sizeof(*pArchive));
 
  

 
 
  
pArchive->mFd = fd;
 
  
这行代码是保存文件句柄。
 
  

 
 
  
if (sysMapFileInShmem(pArchive->mFd,&map) != 0) {
 
  
err = -1;
 
  
LOGW("Map of '%s' failed\n",debugFileName);
 
  
goto bail;
 
  
}
 
  

 
 
  
if (map.length < kEOCDLen) {
 
  
err = -1;
 
  
LOGV("File '%s' too small to be zip(%zd)\n", debugFileName,map.length);
 
  
goto bail;
 
  
}
 
  
这段代码映射文件数据到内存。
 
  

 
 
  

 
 
  
if (!parseZipArchive(pArchive, &map)) {
 
  
err = -1;
 
  
LOGV("Parsing '%s' failed\n",debugFileName);
 
  
goto bail;
 
  
}
 
  
这段代码是分析zip文件。
 
  

 
 
  
/* success */
 
  
err = 0;
 
  
sysCopyMap(&pArchive->mMap, &map);
 
  
map.addr = NULL;
 
  
这段代码拷贝到映射位置。
 
  

 
 
  
bail:
 
  
if (err != 0)
 
  
dexZipCloseArchive(pArchive);
 
  
if (map.addr != NULL)
 
  
sysReleaseShmem(&map);
 
  
return err;
 
  
}
 
  

 
 
  
函数dexZipPrepArchive的处理，主要就是先保存文件句柄，然后创建文件内存映射，调用parseZipArchive函数来分析zip的所有入口点，并记录到相应的hash表里，最后调用sysCopyMap函数来保存到zip文件对象结构里。
 
  

 
 
  
由上面分析可知，dex文件是压缩成zip文件，这样可以减少占用空间。dex文件在系统里是怎么样打开的过程呢？其它经过下面的过程：
 
  
１）系统初始化虚拟机时，会初始化原始方法gDvmNativeMethodSet集合。
 
  
２）在原始方法集合里有一个函数集合dvm_dalvik_system_DexFile，注册它为Ldalvik/system/DexFile串，当虚拟机调用ＤexFile相关函数时，就会调用这些函数来处理Dex文件。
 
  
３）在处理Dex文件时，会调用函数集合：dvm_dalvik_system_DexFile，这个函数集合里，主要有如下函数：
 
  
constDalvikNativeMethod dvm_dalvik_system_DexFile[] = {
 
  
{"openDexFile", "(Ljava/lang/String;Ljava/lang/String;I)I",
 
  
Dalvik_dalvik_system_DexFile_openDexFile},
 
  
{"closeDexFile", "(I)V",
 
  
Dalvik_dalvik_system_DexFile_closeDexFile},
 
  
{"defineClass", "(Ljava/lang/String;Ljava/lang/ClassLoader;ILjava/security/ProtectionDomain;)Ljava/lang/Class;",
 
  
Dalvik_dalvik_system_DexFile_defineClass},
 
  
{"getClassNameList", "(I)[Ljava/lang/String;",
 
  
Dalvik_dalvik_system_DexFile_getClassNameList},
 
  
{"isDexOptNeeded", "(Ljava/lang/String;)Z",
 
  
Dalvik_dalvik_system_DexFile_isDexOptNeeded},
 
  
{NULL, NULL, NULL },
 
  
};
 
  

 
 
  
openDexFile方法对应的原始函数是Dalvik_dalvik_system_DexFile_openDexFile，它是打开Ｄex文件函数。
 
  
closeDexFile方法对应的原始函数是Dalvik_dalvik_system_DexFile_closeDexFile，它是关闭已经打开的Ｄex文件函数。
 
  

 
 
  
４）在Dalvik_dalvik_system_DexFile_openDexFile函数里，调用函数dvmJarFileOpen打开JAR或者ZIP压缩的文件。
 
  
５）在dvmJarFileOpen函数里，调用dexZipOpenArchive来处理ZIP文件，调用dexZipFindEntry函数读取ZIP解压的文件，调用dvmDexFileOpenFromFd函数读取相应的类数据到内存，并返回给虚拟机。
 
  
 
   
从上面可知调用函数Dalvik_dalvik_system_DexFile_openDexFile来打开Ｄex文件，这个函数的源码如下：
 
   
staticvoid Dalvik_dalvik_system_DexFile_openDexFile(const u4* args,
 
   
JValue* pResult)
 
   
{
 
   
StringObject* sourceNameObj =(StringObject*) args[0];
 
   
这行是输入的Jar或Ｄex文件名参数。
 
   

 
 
   
StringObject* outputNameObj =(StringObject*) args[1];
 
   
这行是输出的文件名参数。
 
   

 
 
   
int flags = args[2];
 
   
这行是处理的标示。
 
   

 
 
   
DexOrJar* pDexOrJar = NULL;
 
   
JarFile* pJarFile;
 
   
RawDexFile* pRawDexFile;
 
   
char* sourceName;
 
   
char* outputName;
 
   

 
 
   
if (sourceNameObj == NULL) {
 
   
dvmThrowException("Ljava/lang/NullPointerException;",NULL);
 
   
RETURN_VOID();
 
   
}
 
   
这段代码是当输入文件名称为空对象时，就抛出异常。
 
   

 
 
   

 
 
   
sourceName =dvmCreateCstrFromString(sourceNameObj);
 
   
这行代码调用函数dvmCreateCstrFromString把java字符串转换Ｃ字符串，由于Ｊava对象表示的字符串并不能立即就使用到Ｃ语言里，所以需要转换才能使用。
 
   

 
 
   
if (outputNameObj != NULL)
 
   
outputName =dvmCreateCstrFromString(outputNameObj);
 
   
else
 
   
outputName = NULL;
 
   
这段代码是同样把输出字符串转换Ｃ字符串。
 
   

 
 
   

 
 
   
/*
 
   
* We have to deal with the possibility thatsomebody might try to
 
   
* open one of our bootstrap class DEXfiles. The set of dependencies
 
   
* will be different, and hence the resultsof optimization might be
 
   
* different, which means we'd actually needto have two versions of
 
   
* the optimized DEX: one that only knowsabout part of the boot class
 
   
* path, and one that knows about everythingin it. The latter might
 
   
* optimize field/method accesses based on aclass that appeared later
 
   
* in the class path.
 
   
*
 
   
* We can't let the user-defined classloader open it and start using
 
   
* the classes, since the optimized form ofthe code skips some of
 
   
* the method and field resolution that wewould ordinarily do, and
 
   
* we'd have the wrong semantics.
 
   
*
 
   
* We have to reject attempts to manuallyopen a DEX file from the boot
 
   
* class path. The easiest way to do thisis by filename, which works
 
   
* out because variations in name (e.g."/system/framework/./ext.jar")
 
   
* result in us hitting a differentdalvik-cache entry. It's also fine
 
   
* if the caller specifies their own outputfile.
 
   
*/
 
   
if(dvmClassPathContains(gDvm.bootClassPath, sourceName)) {
 
   
LOGW("Refusing to reopen boot DEX'%s'\n", sourceName);
 
   
dvmThrowException("Ljava/io/IOException;",
 
   
"Re-opening BOOTCLASSPATH DEXfiles is not allowed");
 
   
free(sourceName);
 
   
RETURN_VOID();
 
   
}
 
   
这段代码是判断用户是否加载系统目录下面的Ｄex文件，如果加载就要拒绝这样的操作，因为系统启动时已经加载了一份这样的优化代码，没有必要再次加载一次。
 
   

 
 
   

 
 
   
/*
 
   
* Try to open it directly as a DEX. Ifthat fails, try it as a Zip
 
   
* with a "classes.dex" inside.
 
   
*/
 
   
if (dvmRawDexFileOpen(sourceName,outputName, &pRawDexFile, false) == 0) {
 
   
LOGV("Opening DEX file '%s'(DEX)\n", sourceName);
 
   

 
 
   
pDexOrJar = (DexOrJar*)malloc(sizeof(DexOrJar));
 
   
pDexOrJar->isDex = true;
 
   
pDexOrJar->pRawDexFile = pRawDexFile;
 
   
这段代码是尝试加载Ｄex文件，但基本不存在直接加Ｄex文件的情况，因此在函数dvmRawDexFileOpen还是空函数，没有实际的内容。
 
   

 
 
   

 
 
   
}else if (dvmJarFileOpen(sourceName, outputName, &pJarFile, false)== 0) {
 
   
LOGV("Opening DEX file '%s'(Jar)\n", sourceName);
 
   

 
 
   
pDexOrJar = (DexOrJar*)malloc(sizeof(DexOrJar));
 
   
pDexOrJar->isDex = false;
 
   
pDexOrJar->pJarFile = pJarFile;
 
   
这段代码是加载Jar文件，就是从这里加载Dex文件到缓存里。
 
   

 
 
   
}else {
 
   
LOGV("Unable to open DEX file'%s'\n", sourceName);
 
   
dvmThrowException("Ljava/io/IOException;","unable to open DEX file");
 
   
}
 
   

 
 
   

 
 
   
if (pDexOrJar != NULL) {
 
   
pDexOrJar->fileName = sourceName;
 
   
这行代码保存文件名称到Dex文件对象里。
 
   

 
 
   
/* add to hash table */
 
   
u4 hash = dvmComputeUtf8Hash(sourceName);
 
   
这行代码通过文件名称计算ＨＡＳＨ串，加速对文件的查找速度。
 
   

 
 
   
void* result;
 
   
dvmHashTableLock(gDvm.userDexFiles);
 
   
result =dvmHashTableLookup(gDvm.userDexFiles, hash, pDexOrJar,
 
   
hashcmpDexOrJar, true);
 
   
dvmHashTableUnlock(gDvm.userDexFiles);
 
   
这段代码添加ＨＡＳＨ表里，以便后面查找使用。
 
   

 
 
   
if (result != pDexOrJar) {
 
   
LOGE("Pointer has already beenadded?\n");
 
   
dvmAbort();
 
   
}
 
   

 
 
   
pDexOrJar->okayToFree = true;
 
   
}else
 
   
free(sourceName);
 
   

 
 
   
RETURN_PTR(pDexOrJar);
 
   
这行代码返回打开的文件对象。
 
   

 
 
   
}
 
   

 
 
   
这个函数是通过JAVA调用时输入Ｄex文件名称，然后加载Ｄex文件，最后把这个文件名称放到ＨＡＳＨ表里，然后返回打开的对象。
 
  
 
  
 
   
在上面的函数里，提到使用dvmJarFileOpen函数找到classes.dex文件，并加载到内存里，然后提供后面的函数使用。现在就来分析这个函数的代码，如下：
 
   
intdvmJarFileOpen(const char* fileName, const char* odexOutputName,
 
   
JarFile** ppJarFile, bool isBootstrap)
 
   
{
 
   
在这里提供四个参数，第一个参数fileName是输入的Ｊar的文件名称；第二个参数odexOutputName是进行优化后的Ｄex输出文件；第三个参数ppJarFile是已经打开并缓存到内存里的文件对象；第四个参数isBootstrap是指示是否系统里Ｄex文件。
 
   

 
 
   
ZipArchive archive;
 
   
DvmDex* pDvmDex = NULL;
 
   
char* cachedName = NULL;
 
   
bool archiveOpen = false;
 
   
bool locked = false;
 
   
int fd = -1;
 
   
int result = -1;
 
   

 
 
   
/* Even if we're not going to look at thearchive, we need to
 
   
* open it so we can stuff it intoppJarFile.
 
   
*/
 
   
if (dexZipOpenArchive(fileName, &archive)!= 0)
 
   
goto bail;
 
   
archiveOpen = true;
 
   
这段代码是调用前面介绍的函数dexZipOpenArchive来打开Ｚip文件，并缓存到系统内存里。
 
   

 
 
   

 
 
   
/* If we fork/exec into dexopt, don't letit inherit the archive's fd.
 
   
*/
 
   
dvmSetCloseOnExec(dexZipGetArchiveFd(&archive));
 
   
这行代码设置当执行完成后，关闭这个文件句柄。
 
   

 
 
   
/* First, look for a ".odex"alongside the jar file. It will
 
   
* have the same name/path except for theextension.
 
   
*/
 
   
fd = openAlternateSuffix(fileName, "odex",O_RDONLY, &cachedName);
 
   
if (fd >= 0) {
 
   
这里优先处理优化的Dex文件。
 
   

 
 
   
LOGV("Using alternate file (odex)for %s ...\n", fileName);
 
   
if (!dvmCheckOptHeaderAndDependencies(fd,false, 0, 0, true, true)) {
 
   
LOGE("%s odex has staledependencies\n", fileName);
 
   
free(cachedName);
 
   
close(fd);
 
   
fd = -1;
 
   
goto tryArchive;
 
   
} else {
 
   
LOGV("%s odex has gooddependencies\n", fileName);
 
   
//TODO: make sure that the .odexactually corresponds
 
   
// to the classes.dex inside thearchive (if present).
 
   
// For typical use there will beno classes.dex.
 
   
}
 
   
}else {
 
   
ZipEntry entry;
 
   

 
 
   
tryArchive:
 
   
/*
 
   
* Pre-created .odex absent or stale. Look inside the jar for a
 
   
* "classes.dex".
 
   
*/
 
   
entry = dexZipFindEntry(&archive,kDexInJarName);
 
   
这行代码是从压缩包里找到Dex文件，然后打开这个文件。
 
   

 
 
   
if (entry != NULL) {
 
   
bool newFile = false;
 
   

 
 
   
/*
 
   
* We've found the one we want. Seeif there's an up-to-date copy
 
   
* in the cache.
 
   
*
 
   
* On return, "fd" will beseeked just past the "opt" header.
 
   
*
 
   
* If a stale .odex file is presentand classes.dex exists in
 
   
* the archive, this will *not*return an fd pointing to the
 
   
* .odex file; the fd will point intodalvik-cache like any
 
   
* other jar.
 
   
*/
 
   
if (odexOutputName == NULL) {
 
   
cachedName =dexOptGenerateCacheFileName(fileName,
 
   
kDexInJarName);
 
   
if (cachedName == NULL)
 
   
goto bail;
 
   
这段代码是把Dex文件进行优化处理，并输出到指定的文件。
 
   

 
 
   
} else {
 
   
cachedName =strdup(odexOutputName);
 
   
}
 
   
LOGV("dvmDexCacheStatus:Checking cache for %s (%s)\n",
 
   
fileName, cachedName);
 
   
fd = dvmOpenCachedDexFile(fileName,cachedName,
 
   
dexGetZipEntryModTime(&archive,entry),
 
   
dexGetZipEntryCrc32(&archive,entry),
 
   
isBootstrap, &newFile,/*createIfMissing=*/true);
 
   
这段代码创建缓存的优化文件。
 
   

 
 
   
if (fd < 0) {
 
   
LOGI("Unable to open orcreate cache for %s (%s)\n",
 
   
fileName, cachedName);
 
   
goto bail;
 
   
}
 
   
locked = true;
 
   

 
 
   
/*
 
   
* If fd points to a new file(because there was no cached version,
 
   
* or the cached version was stale),generate the optimized DEX.
 
   
* The file descriptor returned isstill locked, and is positioned
 
   
* just past the optimization header.
 
   
*/
 
   
if (newFile) {
 
   
u8 startWhen, extractWhen,endWhen;
 
   
bool result;
 
   
off_t dexOffset, fileLen;
 
   

 
 
   
dexOffset = lseek(fd, 0,SEEK_CUR);
 
   
result = (dexOffset > 0);
 
   

 
 
   
if (result) {
 
   
startWhen =dvmGetRelativeTimeUsec();
 
   
result =dexZipExtractEntryToFile(&archive, entry, fd);
 
   
extractWhen =dvmGetRelativeTimeUsec();
 
   
这段代码调用函数dexZipExtractEntryToFile从压缩包里解压文件出来。
 
   

 
 
   
}
 
   
if (result) {
 
   
result =dvmOptimizeDexFile(fd, dexOffset,
 
   
dexGetZipEntryUncompLen(&archive,entry),
 
   
fileName,
 
   
dexGetZipEntryModTime(&archive,entry),
 
   
dexGetZipEntryCrc32(&archive,entry),
 
   
isBootstrap);
 
   
这段代码调用函数dvmOptimizeDexFile对Ｄex文件进行优化处理。
 
   

 
 
   
}
 
   

 
 
   
if (!result) {
 
   
LOGE("Unable toextract+optimize DEX from '%s'\n",
 
   
fileName);
 
   
goto bail;
 
   
}
 
   

 
 
   
endWhen =dvmGetRelativeTimeUsec();
 
   
LOGD("DEX prep '%s': unzipin %dms, rewrite %dms\n",
 
   
fileName,
 
   
(int) (extractWhen -startWhen) / 1000,
 
   
(int) (endWhen - extractWhen)/ 1000);
 
   
}
 
   
} else {
 
   
LOGI("Zip is good, but no %sinside, and no valid .odex "
 
   
"file in the samedirectory\n", kDexInJarName);
 
   
goto bail;
 
   
}
 
   
}
 
   

 
 
   
/*
 
   
* Map the cached version. This immediatelyrewinds the fd, so it
 
   
* doesn't have to be seeked anywhere inparticular.
 
   
*/
 
   
if (dvmDexFileOpenFromFd(fd, &pDvmDex)!= 0) {
 
   
LOGI("Unable to map %s in %s\n",kDexInJarName, fileName);
 
   
goto bail;
 
   
}
 
   
这段代码是调用函数dvmDexFileOpenFromFd来缓存Ｄex文件，并分析文件的内容。比如标记是否优化的文件，通过签名检查Dex文件是否合法。
 
   

 
 
   

 
 
   
if (locked) {
 
   
/* unlock the fd */
 
   
if (!dvmUnlockCachedDexFile(fd)) {
 
   
/* uh oh -- this process needs toexit or we'll wedge the system */
 
   
LOGE("Unable to unlock DEXfile\n");
 
   
goto bail;
 
   
}
 
   
locked = false;
 
   
}
 
   
这段代码是保存文件到缓存里，标记这个文件句柄已经保存到缓存。
 
   

 
 
   

 
 
   
LOGV("Successfully opened '%s' in'%s'\n", kDexInJarName, fileName);
 
   

 
 
   
*ppJarFile = (JarFile*) calloc(1,sizeof(JarFile));
 
   
(*ppJarFile)->archive = archive;
 
   
(*ppJarFile)->cacheFileName =cachedName;
 
   
(*ppJarFile)->pDvmDex = pDvmDex;
 
   
cachedName = NULL; // don't free itbelow
 
   
result = 0;
 
   
这段代码已经成功打开压缩包，并读取Dex文件到内存缓存，这里只是设置一些相关信息返回前面的函数处理。
 
   

 
 
   
bail:
 
   
/* clean up, closing the open file */
 
   
if (archiveOpen && result != 0)
 
   
dexZipCloseArchive(&archive);
 
   
free(cachedName);
 
   
if (fd >= 0) {
 
   
if (locked)
 
   
(void) dvmUnlockCachedDexFile(fd);
 
   
close(fd);
 
   
}
 
   
return result;
 
   
}
 
   

 
 
   
本函数主要流程是打开压缩文件，然后找到Ｄex文件，读取出来，并进行分析，然后拷贝到缓存里，再返回给调用函数