Android Studio如何同时调试项目及关联AAR文件？求指导

Hey there, I’ve been right where you are—trying to debug an Android app while digging into issues inside a linked AAR can feel like hitting a wall at first. But don’t worry, there’s a clear path depending on what kind of AAR you’re working with. Let’s break it down step by step:

If the AAR was built from an Android Library module you own, this is the easiest scenario:

• First, move the Library module into the same Android Studio project as your app. If you were previously importing the compiled AAR, ditch that and add the module directly.
• Update your app’s module-level build.gradle to use a module dependency instead of the AAR file. Replace lines like:

  implementation files('libs/your-custom-library.aar')
  

  with:

  implementation project(':your-library-module-name')
  

• Set breakpoints in both your app’s code and the library’s source code where you suspect the issue is.
• Hit the debug button (the green bug icon) to run your app. When execution hits any breakpoint—whether in the app or the library—Android Studio will seamlessly switch to the corresponding source code, letting you inspect variables, step through execution, and diagnose problems just like you would with regular app code.

If the third-party gave you the AAR plus a source code package (zip or folder):

• Add the AAR to your app’s libs folder and set up the dependency normally in your build.gradle:

  implementation files('libs/third-party-lib.aar')
  

• Right-click your app module in the Project view and select Open Module Settings (or press F4).
• In the window that pops up, go to the Libraries tab, find the third-party AAR library, and click the + button next to "Sources". Select the source code folder or zip file provided by the vendor.
• Once linked, you can set breakpoints in the library’s source code and debug it just like your own code—Android Studio will recognize the sources and let you step through them.

If you don’t have access to the original source code, you can still get insights with decompilation:

• First, extract the classes.jar file from the AAR (rename the AAR to .zip, unzip it, and find classes.jar in the root).
• Use Android Studio’s built-in decompiler: when you hit a breakpoint that leads into the AAR, you’ll see a "Source not found" screen. Click Attach Sources, then select the classes.jar file. Android Studio will decompile the bytecode into readable Java code on the fly.
• Alternatively, use a tool like JD-GUI to pre-decompile the classes.jar into a folder of Java files, then attach that folder as sources in Android Studio.
• Note: If the AAR was obfuscated (with ProGuard/R8), variable and method names will be scrambled. If you can get the mapping.txt file from the library provider, import it into Android Studio (via File > New > Import Mapping) to deobfuscate the code and make debugging easier.

• Make sure your app and the AAR are built with the same build type (both debug, ideally). Release builds of AARs often strip debug symbols, so breakpoints won’t work.
• For AARs pulled from remote Maven repositories: Many libraries publish a sources.jar alongside the AAR. Android Studio will automatically download and link these sources if they’re available—just try setting a breakpoint in the library’s code, and it should work without extra steps.

内容的提问来源于stack exchange，提问作者olivier