ART虚拟机是如何内建支持MultiDex的？

1

2

3

4

5

6

7

    public static void install(Context context) {

        if (IS_VM_MULTIDEX_CAPABLE) {

            Log.i(TAG, "VM has multidex support, MultiDex support library is disabled.");

            return;

        }

        //...

}

1

2

  private static final boolean IS_VM_MULTIDEX_CAPABLE =

            isVMMultidexCapable(System.getProperty("java.vm.version"));

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

    /**

     * Identifies if the current VM has a native support for multidex, meaning there is no need for

     * additional installation by this library.

     * @return true if the VM handles multidex

     */

    /* package visible for test */

    static boolean isVMMultidexCapable(String versionString) {

        boolean isMultidexCapable = false;

        if (versionString != null) {

            Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString);

            if (matcher.matches()) {

                try {

                    int major = Integer.parseInt(matcher.group(1));

                    int minor = Integer.parseInt(matcher.group(2));

                    isMultidexCapable = (major > VM_WITH_MULTIDEX_VERSION_MAJOR)

                            || ((major == VM_WITH_MULTIDEX_VERSION_MAJOR)

                                    && (minor >= VM_WITH_MULTIDEX_VERSION_MINOR));

                } catch (NumberFormatException e) {

                    // let isMultidexCapable be false

                }

            }

        }

        Log.i(TAG, "VM with version " + versionString +

                (isMultidexCapable ?

                        " has multidex support" :

                        " does not have multidex support"));

        return isMultidexCapable;

    }

1

2

    private static final int VM_WITH_MULTIDEX_VERSION_MAJOR = 2;

    private static final int VM_WITH_MULTIDEX_VERSION_MINOR = 1;

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

/**

     * Opens a DEX file from a given filename, using a specified file

     * to hold the optimized data.

     *

     * @param sourceName

     *  Jar or APK file with "classes.dex".

     * @param outputName

     *  File that will hold the optimized form of the DEX data.

     * @param flags

     *  Enable optional features.

     */

    private DexFile(String sourceName, String outputName, int flags) throws IOException {

        if (outputName != null) {

            try {

                String parent = new File(outputName).getParent();

                if (Libcore.os.getuid() != Libcore.os.stat(parent).st_uid) {

                    throw new IllegalArgumentException("Optimized data directory " + parent

                            + " is not owned by the current user. Shared storage cannot protect"

                            + " your application from code injection attacks.");

                }

            } catch (ErrnoException ignored) {

                // assume we'll fail with a more contextual error later

            }

        }

        mCookie = openDexFile(sourceName, outputName, flags);

        mFileName = sourceName;

        guard.open("close");

    }

1

2

3

4

5

6

7

8

9

10

11

12

    /*

     * Open a DEX file.  The value returned is a magic VM cookie.  On

     * failure, an IOException is thrown.

     */

    private static int openDexFile(String sourceName, String outputName,

        int flags) throws IOException {

        return openDexFileNative(new File(sourceName).getCanonicalPath(),

                                 (outputName == null) ? null : new File(outputName).getCanonicalPath(),

                                 flags);

    }

    native private static int openDexFileNative(String sourceName, String outputName,

        int flags) throws IOException;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

jstring javaOutputName, jint) {

  ScopedUtfChars sourceName(env, javaSourceName);//Dex或APK路径

  if (sourceName.c_str() == NULL) {

    return 0;

  }

  NullableScopedUtfChars outputName(env, javaOutputName);//优化后的Dex路径

  if (env->ExceptionCheck()) { //侦测到有异常抛出

    return 0;

  }

  ClassLinker* linker = Runtime::Current()->GetClassLinker();//取得类链接器

  std::unique_ptr<std::vector<const DexFile*>> dex_files(new std::vector<const DexFile*>());//Dex文件列表

  std::vector<std::string> error_msgs;//每一个Dex加载后的异常信息,没有异常为空

  bool success = linker->OpenDexFilesFromOat(sourceName.c_str(), outputName.c_str(), &error_msgs,

                                             dex_files.get());

  if (success || !dex_files->empty()) {

    //...

  } else {

    //...

  }

}

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

// Multidex files make it possible that some, but not all, dex files can be broken/outdated. This

// complicates the loading process, as we should not use an iterative loading process, because that

// would register the oat file and dex files that come before the broken one. Instead, check all

// multidex ahead of time.

bool ClassLinker::OpenDexFilesFromOat(const char* dex_location, const char* oat_location,

                                      std::vector<std::string>* error_msgs,

                                      std::vector<const DexFile*>* dex_files) {

  uint32_t dex_location_checksum;

  uint32_t* dex_location_checksum_pointer = &dex_location_checksum;

  bool have_checksum = true;

  std::string checksum_error_msg;

  //检查Sum值

  if (!DexFile::GetChecksum(dex_location, dex_location_checksum_pointer, &checksum_error_msg)) {

    dex_location_checksum_pointer = nullptr;

    have_checksum = false;

  }

//查看目标Oat文件是否已经被加载过了

  const OatFile::OatDexFile* oat_dex_file = FindOpenedOatDexFile(oat_location, dex_location,

                                                                 dex_location_checksum_pointer);

  std::unique_ptr<const OatFile> open_oat_file(

      oat_dex_file != nullptr ? oat_dex_file->GetOatFile() : nullptr);

  if (open_oat_file.get() == nullptr) {

    //异常处理

    //...

  }

  bool success = LoadMultiDexFilesFromOatFile(open_oat_file.get(), dex_location,

                                              dex_location_checksum_pointer,

                                              false, error_msgs, dex_files);

  if (success) {

    //...

  } else {

    //...

  }

//...

}

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

// Loads all multi dex files from the given oat file returning true on success.

//

// Parameters:

//   oat_file - the oat file to load from

//   dex_location - the dex location used to generate the oat file

//   dex_location_checksum - the checksum of the dex_location (may be null for pre-opted files)

//   generated - whether or not the oat_file existed before or was just (re)generated

//   error_msgs - any error messages will be appended here

//   dex_files - the loaded dex_files will be appended here (only if the loading succeeds)

static bool LoadMultiDexFilesFromOatFile(const OatFile* oat_file,

                                         const char* dex_location,

                                         const uint32_t* dex_location_checksum,

                                         bool generated,

                                         std::vector<std::string>* error_msgs,

                                         std::vector<const DexFile*>* dex_files) {

  if (oat_file == nullptr) {

    return false;

  }

  size_t old_size = dex_files->size();

  bool success = true;

  //这个for循环执行的过程中，一旦出现success为false，立刻停止循环

  for (size_t i = 0; success; ++i) {

    std::string next_name_str = DexFile::GetMultiDexClassesDexName(i, dex_location);

    const char* next_name = next_name_str.c_str();

    std::string error_msg;

    //...

    //尝试寻找对应的OAT文件

    const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(next_name, nullptr, false);

    if (oat_dex_file == nullptr) {

      if (i == 0 && generated) {

        std::string error_msg;

        error_msg = StringPrintf("\nFailed to find dex file '%s' (checksum 0x%x) in generated out "

                                 " file'%s'", dex_location, next_location_checksum,

                                 oat_file->GetLocation().c_str());

        error_msgs->push_back(error_msg);

      }

      break;  // Not found, done.

    }

    // Checksum test. Test must succeed when generated.

    success = !generated;

    //...

    if (success) {

      const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);

      if (dex_file == nullptr) {

        success = false;

        error_msgs->push_back(error_msg);

      } else {

        dex_files->push_back(dex_file);

      }

    }

  }//for循环结束

  if (dex_files->size() == old_size) {

    success = false;  // We did not even find classes.dex

  }

  if (success) {

    return true;

  } else {

    // Free all the dex files we have loaded.

    auto it = dex_files->begin() + old_size;

    auto it_end = dex_files->end();

    for (; it != it_end; it++) {

      delete *it;

    }

    dex_files->erase(dex_files->begin() + old_size, it_end);

    return false;

  }

}

1

2

3

4

const DexFile* OatFile::OatDexFile::OpenDexFile(std::string* error_msg) const {

  return DexFile::Open(dex_file_pointer_, FileSize(), dex_file_location_,

                       dex_file_location_checksum_, error_msg);

}

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

bool DexFile::Open(const char* filename, const char* location, std::string* error_msg,

                   std::vector<const DexFile*>* dex_files) {

  uint32_t magic;

  ScopedFd fd(OpenAndReadMagic(filename, &magic, error_msg));

  if (fd.get() == -1) {

    DCHECK(!error_msg->empty());

    return false;

  }

  if (IsZipMagic(magic)) {

   //因为传入的是APK，所以进到这里

    return DexFile::OpenZip(fd.release(), location, error_msg, dex_files);

  }

  if (IsDexMagic(magic)) {

    std::unique_ptr<const DexFile> dex_file(DexFile::OpenFile(fd.release(), location, true,

                                                              error_msg));

    if (dex_file.get() != nullptr) {

      dex_files->push_back(dex_file.release());

      return true;

    } else {

      return false;

    }

  }

  *error_msg = StringPrintf("Expected valid zip or dex file: '%s'", filename);

  return false;

}

1

2

3

4

5

6

7

8

9

bool DexFile::OpenZip(int fd, const std::string& location, std::string* error_msg,

                      std::vector<const  DexFile*>* dex_files) {

  std::unique_ptr<ZipArchive> zip_archive(ZipArchive::OpenFromFd(fd, location.c_str(), error_msg));

  if (zip_archive.get() == nullptr) {

    DCHECK(!error_msg->empty());

    return false;

  }

  return DexFile::OpenFromZip(*zip_archive, location, error_msg, dex_files);

}

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

bool DexFile::OpenFromZip(const ZipArchive& zip_archive, const std::string& location,

                          std::string* error_msg, std::vector<const DexFile*>* dex_files) {

  ZipOpenErrorCode error_code;

  std::unique_ptr<const DexFile> dex_file(Open(zip_archive, kClassesDex, location, error_msg,

                                               &error_code));

  if (dex_file.get() == nullptr) {

    return false;

  } else {

    // Had at least classes.dex.

    dex_files->push_back(dex_file.release());

    // Now try some more.

    size_t i = 2;

    // We could try to avoid std::string allocations by working on a char array directly. As we

    // do not expect a lot of iterations, this seems too involved and brittle.

    while (i < 100) {

      std::string name = StringPrintf("classes%zu.dex", i);

      std::string fake_location = location + kMultiDexSeparator + name;

      std::unique_ptr<const DexFile> next_dex_file(Open(zip_archive, name.c_str(), fake_location,

                                                        error_msg, &error_code));

      if (next_dex_file.get() == nullptr) {

        if (error_code != ZipOpenErrorCode::kEntryNotFound) {

          LOG(WARNING) << error_msg;

        }

        break;

      } else {

        dex_files->push_back(next_dex_file.release());

      }

      i++;

    }

    return true;

  }

}