Hey there! Let's break down your questions step by step—this Java version + Android API compatibility stuff can feel super tangled, so I’ll unpack it clearly for you.

First, let’s confirm your initial hunch: You’re right that the official table shows the maximum Java language version supported by each Android API—but there’s a critical distinction here:

• sourceCompatibility/targetCompatibility control the Java language version you use to write and compile code.
• The Android API’s supported Java version refers to the runtime environment’s ability to execute Java bytecode and APIs.

These are related but separate, and that’s where Desugar (Android’s "desugaring" tool) comes in to bridge the gap for lower API levels.

1. Why You Can Use Java 11 with minSdkVersion=24 (Android 7) #

The key technology here is Desugar, built into the Android Gradle Plugin (AGP). Desugar translates Java 11+ language features (like var, enhanced switch statements, or new collection APIs) into bytecode that Android 7 (API 24) can understand.

Important caveat: Desugar doesn’t support all Java 11 APIs, but it covers most common language features and core library methods. To enable full support for Java 11 core libraries on API 24, you need to turn on core library desugaring.

2. Step-by-Step Configuration to Support Java 11 + minSdk=24 #

Your current setup is already on the right track—here’s how to lock it in and fix the warnings:

a. Keep Java 11 as Source/Target Compatibility

Don’t revert to Java 8! Keep this in your android/app/build.gradle.kts:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    // Sync Kotlin's JVM target if you use Kotlin
    kotlinOptions {
        jvmTarget = "11"
    }
}

b. Enable Core Library Desugaring

This is mandatory to make Java 11 core library APIs work on API 24. Add these lines to your config:

android {
    compileOptions {
        coreLibraryDesugaringEnabled = true
    }
}

dependencies {
    // Use the latest version compatible with your AGP (8.9.1 supports 2.0.x series)
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.4")
}

c. Fix the "Obsolete Java 8" Warnings

The warnings you saw when using Java 8 are just AGP 8.9.1 phasing out legacy Java 8 support (AGP 8.0+ recommends Java 11+ as the default). Since you’re already using Java 11, you can safely suppress these warnings by adding this to your gradle.properties file:

android.suppressObsoleteJavaWarnings=true

3. Version Selection Strategy: Scalability + Latest Features #

For Scalability

• minSdkVersion: Stick with Flutter 3.35.x’s default (24) — it covers ~90%+ of active Android devices, balancing reach and modern feature support.
• Java Compatibility: Java 11 is the sweet spot. It’s fully supported by your AGP 8.9.1, works reliably with Desugar on API 24, and is widely adopted across Android projects. This gives you a stable base that’s easy to maintain as you scale.

For Latest Features

If you want to use Java 17 features (like sealed classes, pattern matching for instanceof), you can bump your compatibility to Java 17 while keeping minSdk=24:

compileOptions {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
    jvmTarget = "17"
}

Just ensure you keep core library desugaring enabled—AGP 8.9.1 fully supports Java 17, so this will work seamlessly on API 24+ devices.

4. ART and Java Version Relationship #

You mentioned sourceCompatibility/targetCompatibility affecting the Android Runtime (ART)—this is partially true:

• targetCompatibility sets the bytecode version the compiler outputs, which ART needs to interpret.
• For devices running API 33+ (Android 13), ART natively supports Java 11 bytecode, so Desugar isn’t required.
• For older devices (API 24-32), Desugar translates Java 11 bytecode into a format ART can understand. As long as Desugar is enabled, you don’t have to worry about ART compatibility for lower API levels.

5. Quick Note on Your Emulator Issue #

Google has marked API 24 emulators as "obsolete" in newer Android Studio versions, but you can still download them from the SDK Manager (look for the "Obsolete" category under system images). If emulators give you trouble, testing on a physical Android 7 device is also a reliable alternative. And it’s totally normal that your minSdk=24 app runs on API 31—Android maintains backward compatibility for apps built for older API levels.

Final Recap #

• Keep sourceCompatibility/targetCompatibility at Java 11 (or 17 for newer features) with core library desugaring enabled to support minSdk=24.
• Ignore or suppress the Java 8 obsolete warnings—you’re already following AGP’s recommended modern setup.
• Choose Java 11 for maximum scalability, or Java 17 if you want the latest language features without dropping support for Android 7.

Does this clear up all your confusion? Let me know if you want to dive deeper into any specific part! 😊