Android java.lang.IncompatibleClassChangeError

最近为了解决一个问题，需要在升级X应用时对其做startInstrumentation。功能上线后，数据监控平台发现存在IncompatibleClassChangeError，主要集中在安卓5.1，6.0，少量在安卓8.0。究竟是怎么回事呢？一起来分析一下。

安卓6.0机器

java.lang.IncompatibleClassChangeError: retrofit2.converter.gson.GsonConverterFactory at dalvik.system.DexFile.defineClassNative(Native Method) at dalvik.system.DexFile.defineClass(DexFile.java:226) at dalvik.system.DexFile.loadClassBinaryName(DexFile.java:219) at dalvik.system.DexPathList.findClass(DexPathList.java:339) at dalvik.system.BaseDexClassLoader.findClass(BaseDexClassLoader.java:54) at java.lang.ClassLoader.loadClass(ClassLoader.java:511) at java.lang.ClassLoader.loadClass(ClassLoader.java:469) at

安卓8.0机器：

java.lang.IncompatibleClassChangeError: Structural change of retrofit2.Converter$Factory is hazardous (/data/app/com.xxx.xx-2zz63J0ZnL47Rw6U5B3wfw==/oat/arm/base.odex at compile time, /data/app/com.xxx.tool-L0IRpZwtps6TiRfTUrRDAw==/oat/arm/base.odex at runtime): Direct method count off: 3 vs 1 Lretrofit2/Converter$Factory; (Compile time): Static fields: Instance fields: Direct methods: ()V getParameterUpperBound(ILjava/lang/reflect/ParameterizedType;)Ljava/lang/reflect/Type;

注意安卓6抛出的AndroidRuntime没有直接说明原因，不如安卓8清晰。

首先看一下IncompatibleClassChangeError的定义：

java.lang.Object
↳	java.lang.Throwable
	↳	java.lang.Error
		↳	java.lang.LinkageError
			↳	java.lang.IncompatibleClassChangeError

当某个类定义发生了不兼容的变更时抛出。当前正在执行的方法所依赖的某个类的类定义已经发生了变化。

问题原因

经过分析源码发现，谷歌在Jan 15, 2015，也就是安卓5.1.1开始，加入了以下提交：

ART: Simple structural class check (123364) · Gerrit Code Review

ART: Simple structural class check
​
Adds a simple check to class-loading when the embedded dex file in
an oat file and the dex file on the class path where we found the
class do not match.
​
We require that the number of methods and fields do not change, as
that will almost certainly mean that quickened and other compiled
offsets are wrong now. This is a reasonably lightweight change, but
we should investigate a full comparison including name and type of
members.

关键方法就是CheckSuperClassChange和SimpleStructuralCheck，简单来说就是当art虚拟机发现加载类的dex路径和父类dex路径不一致时，就会执行SimpleStructuralCheck检查，如果发现来自两个dex文件的父类的方法数、字段数不一致，就会抛出异常。

但是从类的兼容性角度来看，这样的粗暴检查是不合理的。

Add API method	If method need not be reimplemented by Client If method must be reimplemented by Client	Binary compatible (0) Breaks compatibility (1)
Delete API method	-	Breaks compatibility
Move API method up type hierarchy	If method in supertype need not be reimplemented by Client <br If method in supertype must be reimplemented by Client	Binary compatible Breaks compatibility (9)
Move API method down type hierarchy	-	Breaks compatibility (9)
Add API constructor	If there are other constructors If this is only constructor	Binary compatible Breaks compatibility (2)
Delete API constructor	-	Breaks compatibility
Add API field	If class is not subclassable by Client (this includes enums) If class is subclassable by Client	Binary compatible May break compatibility (3)
Delete API field	-	Breaks compatibility
Expand superinterface set (direct or inherited)	-	Binary compatible
Contract superinterface set (direct or inherited)	-	Breaks compatibility (4)
Expand superclass set (direct or inherited)	-	Binary compatible
Contract superclass set (direct or inherited)	-	Breaks compatibility (4)
Add, delete, or change static or instance initializers	-	Binary compatible
Add API type member	-	Binary compatible
Delete API type member	-	Breaks compatibility
Re-order field, method, constructor, and type member declarations	-	Binary compatible
Add or delete non-API members; that is, private or default access fields, methods, constructors, and type members	-	Binary compatible
Change abstract to non-abstract	-	Binary compatible
Change non-abstract to abstract	-	Breaks compatibility (5)
Change final to non-final	-	Binary compatible
Change non-final to final	-	Breaks compatibility (6)
Add type parameter	If class has no type parameters If class has type parameters	Binary compatible (7) Breaks compatibility
Delete type parameter	-	Breaks compatibility
Re-order type parameters	-	Breaks compatibility
Rename type parameter	-	Binary compatible
Add, delete, or change type bounds of type parameter	-	Breaks compatibility
Rename enum constant	-	Breaks compatibility
Add, change, or delete enum constant arguments	-	Binary compatible
Add, change, or delete enum constant class body	-	Binary compatible
Add enum constant	-	Binary compatible (8)
Delete enum constant	-	Breaks compatibility
Re-order enum constants	-	Binary compatible (8)

后面谷歌意识到了这个问题，在安卓8.1去掉了，Revert "ART: Simple structural class check" (421051) · Gerrit Code Review

Revert "ART: Simple structural class check"
​
This reverts commit fd9eb3923dcf417afcf5ed4ebb13867fd10f2de3.
​
Remove the simple structural check. Its naive expectations for
resolution have been wrong since we introduced compiling APKs with
a classpath for shared libraries and have never been updated.

所以，java.lang.IncompatibleClassChangeError: Structural change of ....... 这个错误波及范围是安卓5.1到安卓8.0。

源码分析

安卓6.0

class_linker.cc - OpenGrok cross reference for /art/runtime…

// Very simple structural check on whether the classes match. Only compares the number of
// methods and fields.
 // 校验当前加载的父类与编译时(dex2oat)的父类是否一致(odex中的数据结构)
static bool SimpleStructuralCheck(const DexFile& dex_file1, const DexFile::ClassDef& dex_class_def1,
                                  const DexFile& dex_file2, const DexFile::ClassDef& dex_class_def2,
                                  std::string* error_msg) {
  ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1));
  ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2));
​
  // Counters for current dex file.
  size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1;
  CountMethodsAndFields(dex_data1, &dex_virtual_methods1, &dex_direct_methods1, &dex_static_fields1,
                        &dex_instance_fields1);
  // Counters for compile-time dex file.
  size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2;
  CountMethodsAndFields(dex_data2, &dex_virtual_methods2, &dex_direct_methods2, &dex_static_fields2,
                        &dex_instance_fields2);
​
  if (dex_virtual_methods1 != dex_virtual_methods2) {
    std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
    *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s", dex_virtual_methods1,
                              dex_virtual_methods2, class_dump.c_str());
    return false;
  }
  if (dex_direct_methods1 != dex_direct_methods2) {
    std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
    *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s", dex_direct_methods1,
                              dex_direct_methods2, class_dump.c_str());
    return false;
  }
  if (dex_static_fields1 != dex_static_fields2) {
    std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
    *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s", dex_static_fields1,
                              dex_static_fields2, class_dump.c_str());
    return false;
  }
  if (dex_instance_fields1 != dex_instance_fields2) {
    std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
    *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s", dex_instance_fields1,
                              dex_instance_fields2, class_dump.c_str());
    return false;
  }
​
  return true;
}
​
// klass 表示当前加载的类
// dex_file 为当前加载的类所在的 dex 文件
// class_def 表示当前类在 dex 文件中的数据结构
// super_class 表示当前加载的父类，正常来说(app_image的场景除外)这个类是按照双亲委托模型加载的父类，而要校验的正是这个类
// Checks whether a the super-class changed from what we had at compile-time. This would
// invalidate quickening.
static bool CheckSuperClassChange(Handle<mirror::Class> klass,
                                  const DexFile& dex_file,
                                  const DexFile::ClassDef& class_def,
                                  mirror::Class* super_class)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  // Check for unexpected changes in the superclass.
  // Quick check 1) is the super_class class-loader the boot class loader? This always has
  // precedence.
  if (super_class->GetClassLoader() != nullptr &&
      // Quick check 2) different dex cache? Breaks can only occur for different dex files,
      // which is implied by different dex cache.
      klass->GetDexCache() != super_class->GetDexCache()) {
    // Now comes the expensive part: things can be broken if (a) the klass' dex file has a
    // definition for the super-class, and (b) the files are in separate oat files. The oat files
    // are referenced from the dex file, so do (b) first. Only relevant if we have oat files.
    const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile();
    const OatFile* class_oat_file = nullptr;
    if (class_oat_dex_file != nullptr) {
      class_oat_file = class_oat_dex_file->GetOatFile();
    }
    // class_oat_file不能为空
    if (class_oat_file != nullptr) {
      const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile();
      const OatFile* loaded_super_oat_file = nullptr;
      if (loaded_super_oat_dex_file != nullptr) {
        loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile();
      }
​
      if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) {
        // Now check (a).
        const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_);
        if (super_class_def != nullptr) {
          // Uh-oh, we found something. Do our check.
          std::string error_msg;
          if (!SimpleStructuralCheck(dex_file, *super_class_def,
                                     super_class->GetDexFile(), *super_class->GetClassDef(),
                                     &error_msg)) {
            // Print a warning to the log. This exception might be caught, e.g., as common in test
            // drivers. When the class is later tried to be used, we re-throw a new instance, as we
            // only save the type of the exception.
            LOG(WARNING) << "Incompatible structural change detected: " <<
                StringPrintf(
                    "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
                    PrettyType(super_class_def->class_idx_, dex_file).c_str(),
                    class_oat_file->GetLocation().c_str(),
                    loaded_super_oat_file->GetLocation().c_str(),
                    error_msg.c_str());
            ThrowIncompatibleClassChangeError(klass.Get(),
                "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
                PrettyType(super_class_def->class_idx_, dex_file).c_str(),
                class_oat_file->GetLocation().c_str(),
                loaded_super_oat_file->GetLocation().c_str(),
                error_msg.c_str());
            return false;
          }
        }
      }
    }
  }
  return true;
}

就拿我司应用报的错误来说，A应用在编译时集成了一个新版本的Lretrofit2/Converter$Factory，插桩应用B集成的是一个旧版本的Lretrofit2/Converter$Factory，执行插桩时，A和B是运行在同一个进程的，又因为B应用的classloader路径排在A的前面。所以，当A应用初始化GsonConverterFactory （B不包含这个类）时，根据类双亲委派原则，优先加载的是应用B的Lretrofit2/Converter$Factory，符合CheckSuperClassChange规则：GsonConverterFactory 类的dex路径和父类Lretrofit2/Converter$Factorydex路径不一致，进入了SimpleStructuralCheck检查，这时候就会拿A和B应用里面的Lretrofit2/Converter$Factory类进行检查，结果发现方法数不一致，导致了异常。

疑问

上面源码分析提到在安卓5.1到安卓8.0都有这个检查，但根据监控平台的数据显示在安卓8.0基本不会发生，为什么呢？

我们再来看一下CheckSuperClassChange这个方法，除了要求类和父类来自不同的dex文件，还要求class_oat_file不能为空，也就是对应的odex文件不能为空，否则也不会执行SimpleStructuralCheck。那么什么情况class_oat_file为空呢？那么我们就需要了解oat文件的打开过程了。

oat文件加载流程

在这里我不会详细分析oat文件的加载流程，如需深入了解可以参考附录。我更关心的是class_oat_file在什么情况为空。

oat文件加载流程关键入口是：ClassLinker::OpenDexFilesFromOat

首先来看一下安卓6的：

class_linker.cc - OpenGrok cross reference for /art/runtime…

​
std::vector<std::unique_ptr<const DexFile>> ClassLinker::OpenDexFilesFromOat(
    const char* dex_location, const char* oat_location,
    std::vector<std::string>* error_msgs) {
  CHECK(error_msgs != nullptr);
  .....
  .....
  // Check if we already have an up-to-date oat file open.
  //检查内存是否存在对应的oat文件
  const OatFile* source_oat_file = nullptr;
  {
    ReaderMutexLock mu(Thread::Current(), dex_lock_);
    for (const OatFile* oat_file : oat_files_) {
      CHECK(oat_file != nullptr);
      if (oat_file_assistant.GivenOatFileIsUpToDate(*oat_file)) {
        source_oat_file = oat_file;
        break;
      }
    }
  }
​
  // If we didn't have an up-to-date oat file open, try to load one from disk.
  //如果内存没有则从磁盘加载
  if (source_oat_file == nullptr) {
    // Update the oat file on disk if we can. This may fail, but that's okay.
    // Best effort is all that matters here.
    // 关键地方：检查磁盘的oat文件是否需要更新
    if (!oat_file_assistant.MakeUpToDate(&error_msg)) {
      LOG(WARNING) << error_msg;
    }
​
    // Get the oat file on disk.
    // 从磁盘加载oat文件
    std::unique_ptr<OatFile> oat_file = oat_file_assistant.GetBestOatFile();
    if (oat_file.get() != nullptr) {
      // Take the file only if it has no collisions, or we must take it because of preopting.
      // 关键地方：检查待加载的oat文件是否和已经加载的存在类冲突
      // 如果存在类冲突，考虑直接加载apk里面的dex文件
      bool accept_oat_file = !HasCollisions(oat_file.get(), &error_msg);
      if (!accept_oat_file) {
        // Failed the collision check. Print warning.
        if (Runtime::Current()->IsDexFileFallbackEnabled()) {
          LOG(WARNING) << "Found duplicate classes, falling back to interpreter mode for "
                       << dex_location;
        } else {
          LOG(WARNING) << "Found duplicate classes, dex-file-fallback disabled, will be failing to "
                          " load classes for " << dex_location;
        }
        LOG(WARNING) << error_msg;
​
        // However, if the app was part of /system and preopted, there is no original dex file
        // available. In that case grudgingly accept the oat file.
        // 系统应用大部分都会在编译服务器做dex优化，这时候apk里面就不会包含dex文件了。这种情况的话还是加载oat文件
        if (!DexFile::MaybeDex(dex_location)) {
          accept_oat_file = true;
          LOG(WARNING) << "Dex location " << dex_location << " does not seem to include dex file. "
                       << "Allow oat file use. This is potentially dangerous.";
        }
      }
​
      if (accept_oat_file) {
        // 获取oat文件
        source_oat_file = oat_file.release();
        RegisterOatFile(source_oat_file);
      }
    }
  }
​
  std::vector<std::unique_ptr<const DexFile>> dex_files;
​
  // Load the dex files from the oat file.
  // 加载oat文件里面的dex文件
  if (source_oat_file != nullptr) {
    dex_files = oat_file_assistant.LoadDexFiles(*source_oat_file, dex_location);
    if (dex_files.empty()) {
      error_msgs->push_back("Failed to open dex files from "
          + source_oat_file->GetLocation());
    }
  }
​
  // Fall back to running out of the original dex file if we couldn't load any
  // dex_files from the oat file.
  // 如果加载oat文件里面的dex文件失败，则直接尝试加载apk里面的dex文件。
  if (dex_files.empty()) {
    if (oat_file_assistant.HasOriginalDexFiles()) {
      if (Runtime::Current()->IsDexFileFallbackEnabled()) {
        if (!DexFile::Open(dex_location, dex_location, &error_msg, &dex_files)) {
          LOG(WARNING) << error_msg;
          error_msgs->push_back("Failed to open dex files from " + std::string(dex_location));
        }
      } else {
        error_msgs->push_back("Fallback mode disabled, skipping dex files.");
      }
    } else {
      error_msgs->push_back("No original dex files found for dex location "
          + std::string(dex_location));
    }
  }
  return dex_files;
}

从上面源码分析可以发现，如果dex文件来自于apk而不是oat文件的话class_oat_file就会为空，不会执行SimpleStructuralCheck。

安卓8：

入口也是ClassLinker::OpenDexFilesFromOat，只不过迁移到了oat_file_manager.cc里面：

oat_file_manager.cc - OpenGrok cross reference for /art/runtime…

过程也是大同小异的，研究发现HasCollisions方法有不一样的地方。

安卓6开始引入HasCollisions这个方法

安卓6：

// For b/21333911.
static constexpr bool kDuplicateClassesCheck = false;
​
bool ClassLinker::HasCollisions(const OatFile* oat_file, std::string* error_msg) {
  if (!kDuplicateClassesCheck) { //这个设置成了false
    return false;
  }
    ........
    ........
}

搜索一下kDuplicateClassesCheck看是干什么的，runtime/oat_file_manager.cc - platform/art - Git at Google

// For b/21333911.
// Only enabled for debug builds to prevent bit rot. There are too many performance regressions for
// normal builds.
static constexpr bool kDuplicateClassesCheck = kIsDebugBuild;

所以在安卓6是不会触发这个检查的，查看源码后发现安卓7.0才开始默认启用。

因此，在安卓7.0开始，如果插桩应用或者插件应用包含了和宿主应用一样的类，一般来说，也不会触发SimpleStructuralCheck。

实验

我在一台64位的安卓6.0机器进行插桩和加载插件测试：

插桩测试

安装应用时会做dex优化，生成oat文件。

06-24 16:56:07.393 21329 21384 I PackageManager.DexOptimizer: Running dexopt (dex2oat) on: /data/app/vmdl566966682.tmp/base.apk pkg=com.example.myapplication.myapplication isa=arm vmSafeMode=false debuggable=false oatDir = /data/app/vmdl566966682.tmp/oat
06-24 16:56:07.422  5953  5953 I dex2oat : Starting dex2oat.
06-24 16:56:07.874  5953  5958 I dex2oat : Skipping compilation of long com.alibaba.fastjson.parser.JSONLexer.longValue(): it contains a non natural loop
06-24 16:56:07.933  5953  5958 I dex2oat : Skipping compilation of double[] com.alibaba.fastjson.parser.JSONLexer.scanFieldDoubleArray(long): it contains a non natural loop
06-24 16:56:07.963  5953  5958 I dex2oat : Skipping compilation of float[] com.alibaba.fastjson.parser.JSONLexer.scanFieldFloatArray(long): it contains a non natural loop
06-24 16:56:09.083  5953  5953 I dex2oat : dex2oat took 1.659s (threads: 4) arena alloc=10MB java alloc=971KB native alloc=15MB free=600KB

情况1：64位应用对32位应用做插桩

加载oat文件，执行MakeUpToDate检查时，发现安装时的oat文件不适用于32位环境，需要重新生成oat文件，结果因为权限问题生成失败。结果就是class_oat_file为空，不会执行SimpleStructuralCheck。所以，一般不会出现IncompatibleClassChangeError。

加载类时， fork出来的dex2oat是应用权限，不能对/data/dalvik-cache/（root权限）进行读写。

06-24 16:36:29.851 32154 32154 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/app/com.example.myapplication.myapplication-1/base.apk
06-24 16:36:29.851 32154 32154 W art     : wesley source_oat_file is null
06-24 16:36:29.851 32154 32154 W art     : wesley :GetDexOptNeeded HasOriginalDexFiles: 1
06-24 16:36:29.889 32174 32174 E dex2oat : Failed to create oat file: /data/dalvik-cache/arm/data@app@com.example.myapplication.myapplication-1@base.apk@classes.dex: Permission denied
06-24 16:36:29.889 32174 32174 I dex2oat : dex2oat took 307.667us (threads: 4)
06-24 16:36:29.893 32154 32154 W art     : wesley MakeUpToDate fail: Failed execv(/system/bin/dex2oat --runtime-arg -classpath --runtime-arg  --instruction-set=arm --instruction-set-features=smp,div,-atomic_ldrd_strd --runtime-arg -Xrelocate --boot-image=/system/framework/boot.art --runtime-arg -Xms64m --runtime-arg -Xmx512m --instruction-set-variant=cortex-a7 --instruction-set-features=default --dex-file=/data/app/com.example.myapplication.myapplication-1/base.apk --oat-file=/data/dalvik-cache/arm/data@app@com.example.myapplication.myapplication-1@base.apk@classes.dex) because non-0 exit status
06-24 16:36:29.893 32154 32154 W art     : wesley oat_file is null:
06-24 16:36:29.893 32154 32154 W art     : wesley :HasOriginalDexFiles true
06-24 16:36:29.985 32154 32154 W art     : wesley :load OriginalDexFiles success
06-24 16:36:29.986 32154 32154 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/app/com.tianci.de-2/base.apk
06-24 16:36:29.986 32154 32154 W art     : wesley source_oat_file is null
06-24 16:36:29.989 32154 32154 W art     : wesley :GetDexOptNeeded: kNoDexOptNeeded
06-24 16:36:29.989 32154 32154 W art     : wesley MakeUpToDate success
06-24 16:36:29.989 32154 32154 W art     : wesley accept_oat_file:1

情况2：32位应用对32位应用做插桩

通过adb install --abi armeabi-v7a <path to apk>强制指定应用运行在32位，这种情况class_oat_file不会为空了，就会触发：Incompatible structural change detected: Structural change...... 。

插件加载

情况1：通过PathClassLoader去loadClass（通过adb install安装的插件），会触发：Incompatible structural change detected: Structural change......（两个应用都是64位安装）

情况2：没有安装的插件，应用运行正常，也是因为权限问题做dex2oat失败，直接从apk文件加载了dex。

06-24 16:11:56.975 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/app/com.example.myapplication.myapplication-2/base.apk
06-24 16:11:56.975 24635 24635 W art     : wesley source_oat_file is null
06-24 16:11:56.979 24635 24635 W art     : wesley :GetDexOptNeeded: kNoDexOptNeeded
06-24 16:11:56.979 24635 24635 W art     : wesley MakeUpToDate success
06-24 16:11:56.979 24635 24635 W art     : wesley accept_oat_file:1
06-24 16:11:57.050 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/app/plugin.platform-1/base.apk
06-24 16:11:57.050 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/app/plugin.platform-1/base.apk
06-24 16:11:57.050 24635 24635 W art     : wesley source_oat_file is null
06-24 16:11:57.053 24635 24635 W art     : wesley :GetDexOptNeeded: kNoDexOptNeeded
06-24 16:11:57.053 24635 24635 W art     : wesley MakeUpToDate success
06-24 16:11:57.053 24635 24635 W art     : wesley accept_oat_file:1
​
06-24 16:11:57.063 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/user/0/com.example.myapplication.myapplication/files/Plugin.apk
06-24 16:11:57.063 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/user/0/com.example.myapplication.myapplication/files/Plugin.apk
06-24 16:11:57.063 24635 24635 W art     : wesley GivenOatFileIsUpToDate is false, dex_location:/data/user/0/com.example.myapplication.myapplication/files/Plugin.apk
06-24 16:11:57.063 24635 24635 W art     : wesley source_oat_file is null
06-24 16:11:57.063 24635 24635 W art     : wesley :GetDexOptNeeded HasOriginalDexFiles: 1
06-24 16:11:57.107 24661 24661 E dex2oat : Failed to create oat file: /data/dalvik-cache/arm64/data@user@0@com.example.myapplication.myapplication@files@Plugin.apk@classes.dex: Permission denied
06-24 16:11:57.107 24661 24661 I dex2oat : dex2oat took 295.167us (threads: 4)
06-24 16:11:57.108 24635 24635 W art     : wesley MakeUpToDate fail: Failed execv(/system/bin/dex2oat --runtime-arg -classpath --runtime-arg  --instruction-set=arm64 --instruction-set-features=smp,a53 --runtime-arg -Xrelocate --boot-image=/system/framework/boot.art --runtime-arg -Xms64m --runtime-arg -Xmx512m --instruction-set-variant=generic --instruction-set-features=default --dex-file=/data/user/0/com.example.myapplication.myapplication/files/Plugin.apk --oat-file=/data/dalvik-cache/arm64/data@user@0@com.example.myapplication.myapplication@files@Plugin.apk@classes.dex) because non-0 exit status
06-24 16:11:57.108 24635 24635 W art     : wesley oat_file is null:
06-24 16:11:57.108 24635 24635 W art     : wesley :HasOriginalDexFiles true
06-24 16:11:57.121 24635 24635 W art     : wesley :load OriginalDexFiles success

解决

看完上面的内容后，应该很容易知道怎么解决了。要么就是想办法通过SimpleStructuralCheck，要么就是想办法不进人SimpleStructuralCheck。

想办法通过SimpleStructuralCheck：插桩或者插件的类和宿主保持一致。

想办法不进人SimpleStructuralCheck：插件compileOnly公共接口；插件不安装，以文件的方式进行加载；插件安装，类加载入口中转到插件文件等等。

参考

插件化之 Incompatible structural change detected 问题分析 - 掘金

[原创]菜鸟学8.1版本dex加载流程笔记--第一篇：oat_file_manager与oat_file_assistant-Android安全-看雪-安全社区|安全招聘|kanxue.com

Chapter 13. Binary Compatibility