抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

Android类加载器层级关系及分析

发布于：2024年11月21日

次浏览

有关类的加载在andriod_system_opreation_process篇

Android中的ClassLoader类型分为系统ClassLoader和自定义ClassLoader。其中系统ClassLoader包括3种是BootClassLoader、DexClassLoader、PathClassLoader
(1)BootClassLoader:Android平台上所有Android系统启动时会使用BootClassLoader来预加载常用的类
(2)BaseDexClassLoader:实际应用层类文件的加载，而真正的加载委托给pathList来完成
(3)DexClassLoader:可以加载dex文件以及包含dex的压缩文件(apk,dex,jar,zip),可以安装一个未安装的apk文件，一般为自定义类加载器
(4)PathClassLoader:可以加载系统类和应用程序的类，通常用来加载已安装的apk的dex文件
Android 提供的原生加载器叫做基础类加载器，包括：BootClassLoader，PathClassLoader，DexClassLoader，InMemoryDexClassLoader（Android 8.0 引入），DelegateLastClassLoader（Android 8.1 引入）

Android Code Search 安卓源码搜索网址 本文以15.0.0_r3为例分析

PathClassLoader

用于系统和app的类加载器,其中optimizedDirectory为null

PathClassLoader 是作为应用程序的系统类加载器，也是在 Zygote 进程启动的时候初始化的，它通常用于加载 已经安装的apk 里面的 .dex 文件。

（基本流程为：ZygoteInit.main() -> ZygoteInit.forkSystemServer() -> ZygoteInit.handleSystemServerProcess() -> ZygoteInit.createPathClassLoader()。在预加载基本类之后执行），所以每一个 APP 进程从 Zygote 中 fork 出来之后都自动携带了一个 PathClassLoader。

1
2
3
4
5
6
7
8
9
10
11
12
//路径：libcore/dalvik/src/main/java/dalvik/system/PathClassLoader.java
public class PathClassLoader extends BaseDexClassLoader {
    
    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }
    
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
    
}

DexClassLoader

从包含classes.dex的jar或者apk中，加载类的类加载器, 可用于执行动态加载, 但必须是app私有可写目录来缓存odex文件. 能够加载系统没有安装的apk或者jar文件， 因此很多热修复和插件化方案都是采用DexClassLoader

1
2
3
4
5
6
7
8
9
//路径：libcore/dalvik/src/main/java/dalvik/system/DexClassLoader.java
public class DexClassLoader extends BaseDexClassLoader {
    
     public DexClassLoader(String dexPath, String optimizedDirectory,
            String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
    
}

DexClassLoader提供了optimizedDirectory，而PathClassLoader则没有，optimizedDirectory用来存放odex文件的地方，所以可以利用DexClassLoader实现动态加载

BaseDexClassLoader

BaseDexClassLoader会初始化dexPathList，收集dex文件和Native文件动态库

1
2
3
4
5
6
7
8
9
10
//路径：libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
                          String librarySearchPath, ClassLoader parent) {
    super(parent);
    this.pathList = new DexPathList(this, dexPath, librarySearchPath, null);

    if (reporter != null) {
        reporter.report(this.pathList.getDexPaths());
    }
}

dexPath: 包含目标类或资源的apk/jar列表;当有多个路径则采用:分割;
optimizedDirectory: 优化后dex文件存在的目录, 可以为null;
libraryPath: native库所在路径列表;当有多个路径则采用:分割;
ClassLoader:父类的类加载器

DexPathList()

主要负责管理和解析类加载器中涉及的 DEX 文件路径、优化后的 ODEX 文件、以及本地库（Native Libraries）的搜索路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//路径：libcore/dalvik/src/main/java/dalvik/system/DexPathList.java
public final class DexPathList {
    private Element[] dexElements;// DEX 文件/路径，dexElements: 根据多路径的分隔符“;”将dexPath转换成File列表，记录所有的dexFile
    private final List<File> nativeLibraryDirectories;// 本地库目录// 系统本地库路径，记录所有的Native动态库, 包括app目录的native库和系统目录的native库
    private final List<File> systemNativeLibraryDirectories;// 系统本地库路径

        public DexPathList(ClassLoader definingContext, String dexPath, String librarySearchPath, File optimizedDirectory，boolean isTrusted) {
            ......
                this.definingContext = definingContext;

            ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
            // 解析 dexPath，生成 dexElements
            this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                                           suppressedExceptions, definingContext, isTrusted);//
            // 解析 librarySearchPath，生成 nativeLibraryDirectories
            this.nativeLibraryDirectories = splitPaths(librarySearchPath, false);
             // 初始化系统本地库路径
            this.systemNativeLibraryDirectories = splitPaths(System.getProperty("java.library.path"), true);
            List<File> allNativeLibraryDirectories = new ArrayList<>(nativeLibraryDirectories);
            allNativeLibraryDirectories.addAll(systemNativeLibraryDirectories);

            this.nativeLibraryPathElements = makePathElements(allNativeLibraryDirectories);//

            if (suppressedExceptions.size() > 0) {
                this.dexElementsSuppressedExceptions =
                    suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);
            } else {
                dexElementsSuppressedExceptions = null;
            }
        }
    }
}

makeDexElements

makeDexElements方法的作用是获取一个包含dex文件的元素集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//路径：libcore/dalvik/src/main/java/dalvik/system/DexPathList.java
private static Element[] makePathElements(List<File> files, File optimizedDirectory,
            List<IOException> suppressedExceptions) {
        return makeDexElements(files, optimizedDirectory, suppressedExceptions, null);
    }
private static Element[] makeDexElements(List<File> files, File optimizedDirectory,
            List<IOException> suppressedExceptions, ClassLoader loader) {
        return makeDexElements(files, optimizedDirectory, suppressedExceptions, loader, false);
    }
private static Element[] makeDexElements(List<File> files, File optimizedDirectory,
                                         List<IOException> suppressedExceptions, ClassLoader loader, boolean isTrusted) {
    Element[] elements = new Element[files.size()];
    int elementsPos = 0;
	//遍历所有文件
    for (File file : files) {
        if (file.isDirectory()) {//文件夹
            elements[elementsPos++] = new Element(file);
        } else if (file.isFile()) {//文件
            String name = file.getName();

            if (name.endsWith(DEX_SUFFIX)) {// 判断文件后缀名，DEX_SUFFIX = ".dex"
                try {
                    //调用loadDexFile加载dex文件
                    DexFile dex = loadDexFile(file, optimizedDirectory, loader, elements);
                    if (dex != null) {
                        elements[elementsPos++] = new Element(dex, null);
                    }
                } catch (IOException suppressed) {
                    System.logE("Unable to load dex file: " + file, suppressed);
                    suppressedExceptions.add(suppressed);
                }
            } else {//zip file?
                DexFile dex = null;
                try {
                    dex = loadDexFile(file, optimizedDirectory, loader, elements);
                } catch (IOException suppressed) {//zip中没有dex文件
                    suppressedExceptions.add(suppressed);
                }

                if (dex == null) {
                    elements[elementsPos++] = new Element(file);
                } else {
                    elements[elementsPos++] = new Element(dex, file);
                }
            }
        } else {
            System.logW("ClassLoader referenced unknown path: " + file);
        }
    }
    if (elementsPos != elements.length) {
        elements = Arrays.copyOf(elements, elementsPos);
    }
    return elements;
}

loadDexFile()

加载DexFile文件，而且会把优化后的dex文件缓存到对应目录

1
2
3
4
5
6
7
8
9
10
//路径：libcore/dalvik/src/main/java/dalvik/system/DexPathList.java
private static DexFile loadDexFile(File file, File optimizedDirectory, ClassLoader loader,
                                   Element[] elements) throws IOException {
    if (optimizedDirectory == null) {
        return new DexFile(file, loader, elements);
    } else {
        String optimizedPath = optimizedPathFor(file, optimizedDirectory);
        return DexFile.loadDex(file.getPath(), optimizedPath, 0, loader, elements);
    }
}

DexFile()

用来描述Dex文件，Dex的加载以及Class的查找都是由该类调用它的native方法完成的

1
2
3
4
5
6
7
8
9
10
11
12
13
//路径：libcore/dalvik/src/main/java/dalvik/system/DexFile.java
DexFile(File file, ClassLoader loader, DexPathList.Element[] elements)
    throws IOException {
    this(file.getPath(), loader, elements);
}

//进而调用
DexFile(String fileName, ClassLoader loader, DexPathList.Element[] elements) throws IOException {
    mCookie = openDexFile(fileName, null, 0, loader, elements);
    mInternalCookie = mCookie;
    mFileName = fileName;
    //System.out.println("DEX FILE cookie is " + mCookie + " fileName=" + fileName);
}

DexFile.loadDex()

加载DexFile文件，而且会把优化后的dex文件缓存到对应目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//路径：libcore/dalvik/src/main/java/dalvik/system/DexFile.java
static DexFile loadDex(String sourcePathName, String outputPathName,
                       int flags, ClassLoader loader, DexPathList.Element[] elements) throws IOException {
    return new DexFile(sourcePathName, outputPathName, flags, loader, elements);
}

//进而调用
private DexFile(String sourceName, String outputName, int flags, ClassLoader loader,
                DexPathList.Element[] elements) throws IOException {
    ......
    mCookie = openDexFile(sourceName, outputName, flags, loader, elements);
    mInternalCookie = mCookie;
    mFileName = sourceName;
    //System.out.println("DEX FILE cookie is " + mCookie + " sourceName=" + sourceName + " outputName=" + outputName);
}

openDexFile()

1
2
3
4
5
6
7
8
9
10
11
12
//路径：/libcore/dalvik/src/main/java/dalvik/system/DexFile.java
private static Object openDexFile(String sourceName, String outputName, int flags,
                                  ClassLoader loader, DexPathList.Element[] elements) throws IOException {
    // Use absolute paths to enable the use of relative paths when testing on host.
    return openDexFileNative(new File(sourceName).getAbsolutePath(),
                             (outputName == null)
                             ? null
                             : new File(outputName).getAbsolutePath(),
                             flags,
                             loader,
                             elements);
}

sourceName为PathClassLoader构造函数传递的dexPath中以分隔符划分之后的文件名；
outputName为null；
flags = 0
loader为null；
elements为makeDexElements()过程生成的Element数组；

openDexFileNative()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//路径：art/runtime/native/dalivk_system_DexFile.cc
static jobject DexFile_openDexFileNative(JNIEnv* env,
                                         jclass,
                                         jstring javaSourceName,
                                         jstring javaOutputName ATTRIBUTE_UNUSED,
                                         jint flags ATTRIBUTE_UNUSED,
                                         jobject class_loader,
                                         jobjectArray dex_elements) {
    ScopedUtfChars sourceName(env, javaSourceName);
    if (sourceName.c_str() == nullptr) {
        return 0;
    }

    Runtime* const runtime = Runtime::Current();
    ClassLinker* linker = runtime->GetClassLinker();
    std::vector<std::unique_ptr<const DexFile>> dex_files;
    std::vector<std::string> error_msgs;
    const OatFile* oat_file = nullptr;
	//打开oat文件
    dex_files = runtime->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(),
                                                                 class_loader,
                                                                 dex_elements,
                                                                 /*out*/ &oat_file,
                                                                 /*out*/ &error_msgs);

    if (!dex_files.empty()) {
        jlongArray array = ConvertDexFilesToJavaArray(env, oat_file, dex_files);
        if (array == nullptr) {
            ScopedObjectAccess soa(env);
            for (auto& dex_file : dex_files) {
                if (linker->IsDexFileRegistered(soa.Self(), *dex_file)) {
                    dex_file.release();
                }
            }
        }
        return array;
    } else {
       ......
    }
}

OpenDexFilesFromOat

它的主要作用是解析 OAT 文件并提取出嵌入的 DEX 文件，为后续的类加载过程服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
//路径：art/runtime/oat/oat_file_manager.cc
std::vector<std::unique_ptr<const DexFile>> OatFileManager::OpenDexFilesFromOat(
    const char* dex_location,
    jobject class_loader,
    jobjectArray dex_elements,
    const OatFile** out_oat_file,
    std::vector<std::string>* error_msgs) {
  ScopedTrace trace(StringPrintf("%s(%s)", __FUNCTION__, dex_location));
  CHECK(dex_location != nullptr);
  CHECK(error_msgs != nullptr);
    
  std::vector<std::unique_ptr<const DexFile>> dex_files;//定义一个存储 DexFile 的动态数组
  std::unique_ptr<ClassLoaderContext> context(
      ClassLoaderContext::CreateContextForClassLoader(class_loader, dex_elements));//定义一个指向 ClassLoaderContext 对象的 unique_ptr

  //创建了一个 OatFileAssistant 对象
  if (class_loader == nullptr) {
    LOG(WARNING) << "Opening an oat file without a class loader. "
                 << "Are you using the deprecated DexFile APIs?";
  } else if (context != nullptr) {
    auto oat_file_assistant = std::make_unique<OatFileAssistant>(dex_location,
                                                                 kRuntimeISA,
                                                                 context.get(),
                                                                 runtime->GetOatFilesExecutable(),
                                                                 only_use_system_oat_files_);

...
    // 使用 OatFileAssistant 来选择最佳的 .oat 文件
    std::unique_ptr<const OatFile> oat_file(oat_file_assistant->GetBestOatFile().release());
    VLOG(oat) << "OatFileAssistant(" << dex_location << ").GetBestOatFile()="
              << (oat_file != nullptr ? oat_file->GetLocation() : "")
              << " (executable=" << (oat_file != nullptr ? oat_file->IsExecutable() : false) << ")";
...
    
      if (!added_image_space) {
        DCHECK(dex_files.empty());
...//OAT文件的优化
      // 从指定的 .oat 文件中加载 DEX 文件
        if (oat_file != nullptr) {
          dex_files = oat_file_assistant->LoadDexFiles(*oat_file.get(), dex_location);
            ...
        }
      }
      if (dex_files.empty()) {
        ScopedTrace failed_to_open_dex_files("FailedToOpenDexFilesFromOat");
        error_msgs->push_back("Failed to open dex files from " + odex_location);
      } else if (should_madvise) {
       //...dex文件优化
        }
      }
      if (oat_file != nullptr) {
        VLOG(class_linker) << "Registering " << oat_file->GetLocation();
        *out_oat_file = RegisterOatFile(std::move(oat_file));
      }
    } else {
      // oat_file == nullptr
      // 校验类路径中是否已经有正在加载的 dex 文件。
      // 如果是，则报告错误并提供当前堆栈跟踪。
      // 很可能开发人员并不打算这样做，因为这会浪费 // 性能和内存。
      // 性能和内存。
     ...
    }
  }

  //如果 Dex 文件加载失败，代码会尝试通过 ArtDexFileLoader 类重新加载，并提供详细的错误信息。
  if (dex_files.empty()) {
    std::string error_msg;
    static constexpr bool kVerifyChecksum = true;
    ArtDexFileLoader dex_file_loader(dex_location);
    if (!dex_file_loader.Open(Runtime::Current()->IsVerificationEnabled(),
                              kVerifyChecksum,
                              /*out*/ &error_msg,
                              &dex_files)) {
      ScopedTrace fail_to_open_dex_from_apk("FailedToOpenDexFilesFromApk");
      LOG(WARNING) << error_msg;
      error_msgs->push_back("Failed to open dex files from " + std::string(dex_location)
                            + " because: " + error_msg);
    }
  }
...
  return dex_files;
}

LoadDexFiles()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//art/runtime/oat/oat_file_assistant.cc
bool OatFileAssistant::LoadDexFiles(const OatFile& oat_file,
                                    const std::string& dex_location,
                                    std::vector<std::unique_ptr<const DexFile>>* out_dex_files) {
  // Load the main dex file.
  std::string error_msg;
  //通过oat_file.GetOatDexFile()获得oat、dex文件
  const OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_location.c_str(), &error_msg);
  if (oat_dex_file == nullptr) {
    LOG(WARNING) << error_msg;
    return false;
  }
  //通过oat_dex_file->OpenDexFile()打开dex文件
  std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error_msg); 
  if (dex_file.get() == nullptr) {
    LOG(WARNING) << "Failed to open dex file from oat dex file: " << error_msg;
    return false;
  }
    //添加dex文件到dex_files数组中
  out_dex_files->push_back(std::move(dex_file));

   // 看是否存在多个dex文件
  for (size_t i = 1;; i++) {
    std::string multidex_dex_location = DexFileLoader::GetMultiDexLocation(i, dex_location.c_str());
    oat_dex_file = oat_file.GetOatDexFile(multidex_dex_location.c_str());
    if (oat_dex_file == nullptr) {
      // There are no more multidex entries to load.
      break;
    }
    //打开第i个dex文件
    dex_file = oat_dex_file->OpenDexFile(&error_msg);
    if (dex_file.get() == nullptr) {
      LOG(WARNING) << "Failed to open dex file from oat dex file: " << error_msg;
      return false;
    }
    //添加dex文件到dex_files数组中
    out_dex_files->push_back(std::move(dex_file));
  }
  return true;
}

GetOatDexFile（）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//art/runtime/oat/oat_file.cc
const OatDexFile* OatFile::GetOatDexFile(const char* dex_location, std::string* error_msg) const {
   
  const OatDexFile* oat_dex_file = nullptr;
  std::string_view key(dex_location);
  //通过key在oat_dex_files_map中找到dex文件所在位置
  auto primary_it = oat_dex_files_.find(key);
  if (primary_it != oat_dex_files_.end()) {
    oat_dex_file = primary_it->second;
    DCHECK(oat_dex_file != nullptr);
  } else {
    // This dex_location is not one of the dex locations directly mentioned in the
    // oat file. The correct lookup is via the canonical location but first see in
    // the secondary_oat_dex_files_ whether we've looked up this location before.
    MutexLock mu(Thread::Current(), secondary_lookup_lock_);
    auto secondary_lb = secondary_oat_dex_files_.lower_bound(key);
    if (secondary_lb != secondary_oat_dex_files_.end() && key == secondary_lb->first) {
      oat_dex_file = secondary_lb->second;  // May be null.
    } else {
      // We haven't seen this dex_location before, we must check the canonical location.
      std::string dex_canonical_location = DexFileLoader::GetDexCanonicalLocation(dex_location);
      if (dex_canonical_location != dex_location) {
        std::string_view canonical_key(dex_canonical_location);
        auto canonical_it = oat_dex_files_.find(canonical_key);
        if (canonical_it != oat_dex_files_.end()) {
          oat_dex_file = canonical_it->second;
        }  // else keep null.
      }  // else keep null.

      // Copy the key to the string_cache_ and store the result in secondary map.
      string_cache_.emplace_back(key.data(), key.length());
      std::string_view key_copy(string_cache_.back());
      secondary_oat_dex_files_.PutBefore(secondary_lb, key_copy, oat_dex_file);
    }
  }
  if (oat_dex_file == nullptr) {
    if (error_msg != nullptr) {
      std::string dex_canonical_location = DexFileLoader::GetDexCanonicalLocation(dex_location);
      *error_msg = "Failed to find OatDexFile for DexFile " + std::string(dex_location)
          + " (canonical path " + dex_canonical_location + ") in OatFile " + GetLocation();
    }
    return nullptr;
  }

  return oat_dex_file;
}

OatDexFile::OpenDexFile

1
2
3
4
5
6
7
8
9
10
11
12
13
//art/runtime/oat/oat_file.cc
std::unique_ptr<const DexFile> OatDexFile::OpenDexFile(std::string* error_msg) const {
  ScopedTrace trace(__PRETTY_FUNCTION__);
  static constexpr bool kVerify = false;
  static constexpr bool kVerifyChecksum = false;
  ArtDexFileLoader dex_file_loader(dex_file_container_, dex_file_location_);
  return dex_file_loader.OpenOne(dex_file_pointer_ - dex_file_container_->Begin(),
                                 dex_file_location_checksum_,
                                 this,
                                 kVerify,
                                 kVerifyChecksum,
                                 error_msg);
}

dex_file_loader.OpenOne

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//art/libdexfile/dex/dex_file_loader.cc
std::unique_ptr<const DexFile> DexFileLoader::OpenOne(size_t header_offset,
                                                      uint32_t location_checksum,
                                                      const OatDexFile* oat_dex_file,
                                                      bool verify,
                                                      bool verify_checksum,
                                                      std::string* error_msg) {
    //记录操作范围
  DEXFILE_SCOPED_TRACE(std::string("Open dex file ") + location_);

  uint32_t magic;
  if (!InitAndReadMagic(header_offset, &magic, error_msg) || !MapRootContainer(error_msg)) {
    DCHECK(!error_msg->empty());
    return {};
  }
    //验证根容器
  DCHECK(root_container_ != nullptr);
  DCHECK_LE(header_offset, root_container_->Size());
    //加载DEX文件内容
  std::unique_ptr<const DexFile> dex_file = OpenCommon(root_container_,
                                                       root_container_->Begin() + header_offset,
                                                       root_container_->Size() - header_offset,
                                                       location_,
                                                       location_checksum,
                                                       oat_dex_file,
                                                       verify,
                                                       verify_checksum,
                                                       error_msg,
                                                       nullptr);
  return dex_file;
}

DexFileLoader::OpenCommon

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
//art/libdexfile/dex/dex_file_loader.cc
std::unique_ptr<DexFile> DexFileLoader::OpenCommon(std::shared_ptr<DexFileContainer> container,//指向包含DEX文件数据的容器对象
                                                   const uint8_t* base,//指向文件数据的起始地址。
                                                   size_t app_compat_size,//与应用兼容的文件大小。
                                                   const std::string& location,//表示DEX文件的位置路径。
                                                   std::optional<uint32_t> location_checksum,//文件的校验和（可选值）。
                                                   const OatDexFile* oat_dex_file,//关联的OatDexFile对象。
                                                   bool verify,//是否启用DEX文件验证。
                                                   bool verify_checksum,//是否校验文件的校验和。
                                                   std::string* error_msg,//指向用于存储错误消息的字符串指针。
                                                   DexFileLoaderErrorCode* error_code//指向用于存储错误代码的指针。
                                                  ) {
    //容器的初始化
  if (container == nullptr) {
    // We should never pass null here, but use reasonable default for app compat anyway.
    container = std::make_shared<MemoryDexFileContainer>(base, app_compat_size);
  }
  CHECK_GE(base, container->Begin());
  CHECK_LE(base, container->End());
  const size_t size = container->End() - base;
  if (error_code != nullptr) {
    *error_code = DexFileLoaderErrorCode::kDexFileError;
  }
    //创建DEX文件实例
  std::unique_ptr<DexFile> dex_file;
  auto header = reinterpret_cast<const DexFile::Header*>(base);
  if (size >= sizeof(StandardDexFile::Header) && StandardDexFile::IsMagicValid(base)) {
    uint32_t checksum = location_checksum.value_or(header->checksum_);
    dex_file.reset(new StandardDexFile(base, location, checksum, oat_dex_file, container));
  } else if (size >= sizeof(CompactDexFile::Header) && CompactDexFile::IsMagicValid(base)) {
    uint32_t checksum = location_checksum.value_or(header->checksum_);
    dex_file.reset(new CompactDexFile(base, location, checksum, oat_dex_file, container));
  } else {
    *error_msg = StringPrintf("Invalid or truncated dex file '%s'", location.c_str());
  }
  if (dex_file == nullptr) {
    *error_msg =
        StringPrintf("Failed to open dex file '%s': %s", location.c_str(), error_msg->c_str());
    return nullptr;
  }
   //文件初始化
  if (!dex_file->Init(error_msg)) {
    dex_file.reset();
    return nullptr;
  }
  //可选校验
  if (verify && !dex_file->IsCompactDexFile()) {
    DEXFILE_SCOPED_TRACE(std::string("Verify dex file ") + location);
    if (!dex::Verify(dex_file.get(), location.c_str(), verify_checksum, error_msg)) {
      if (error_code != nullptr) {
        *error_code = DexFileLoaderErrorCode::kVerifyError;
      }
      return nullptr;
    }
  }
  if (error_code != nullptr) {
    *error_code = DexFileLoaderErrorCode::kNoError;
  }
  return dex_file;
}

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：http://example.com/2024/11/21/Android%E7%B1%BB%E5%8A%A0%E8%BD%BD%E5%99%A8%E5%B1%82%E7%BA%A7%E5%85%B3%E7%B3%BB%E5%8F%8A%E5%88%86%E6%9E%90/

更新于：2024年11月21日

评论