Add Java-Gradle-AGP validation to flutter analyze (#123916)

https://github.com/flutter/flutter/issues/123917

Doc covering a broad set of issues related to android studio updating. 

https://docs.google.com/document/d/1hTXkjbUrBnXgu8NQsth1c3aEqo77rWoEj8CcsQ39wwQ/edit?pli=1#

Specifically this pr: 
- Adds new functions to find a projects AGP, Gradle and java versions,
and tests.
- Adds new functions that take versions and parse if the versions are
compatible with each other, and tests.
- Adds validator for `flutter analyze --suggestions` that evaluates the
java/gradle/agp versions and checks if they are compatible, and
integration test.
- Updates the version of gradle used by
dev/integration_tests/flutter_gallery/ to the minimum supported by java
18 so that the integration tests pass (It is unknown why the java
version is 18.9 instead of 11)
- Moves `isWithinVersionRange` to version.dart, and tests. 
- Adds FakeAndroidStudio to fakes to be used in multiple tests but does
not remove existing copies.

Metrics will be included as part of the definition of done for this bug
but not as part of this cl. It is already too big.

Known work still left in this pr: 
* Understand why analyze integration tests are failing. 


Example output if Java and gradle are not compatible: 
```
┌───────────────────────────────────────────────────────────────────┐
│ General Info                                                      │
│ [✓] App Name: espresso_example                                    │
│ [✓] Supported Platforms: android                                  │
│ [✓] Is Flutter Package: yes                                       │
│ [✓] Uses Material Design: yes                                     │
│ [✓] Is Plugin: no                                                 │
│ [✗] Java/Gradle/Android Gradle Plugin:                            │
│                                                                   │
│ Incompatible Java/Gradle versions.                                │
│                                                                   │
│ Java Version: 17.0.6, Gradle Version: 7.0.2                       │
│                                                                   │
│ See the link below for more information.                          │
│ https://docs.gradle.org/current/userguide/compatibility.html#java │
│                                                                   │
└───────────────────────────────────────────────────────────────────┘
```
Example output if Gradle and AGP are not compatible
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ General Info                                                                │
│ [✓] App Name: espresso_example                                              │
│ [✓] Supported Platforms: android                                            │
│ [✓] Is Flutter Package: yes                                                 │
│ [✓] Uses Material Design: yes                                               │
│ [✓] Is Plugin: no                                                           │
│ [✗] Java/Gradle/Android Gradle Plugin: Incompatible Gradle/AGP versions.    │
│                                                                             │
│ Gradle Version: 7.0.2, AGP Version: 7.4.2                                   │
│                                                                             │
│ Update gradle to at least "7.5".                                            │
│ See the link below for more information:                                    │
│ https://developer.android.com/studio/releases/gradle-plugin#updating-gradle │
│                                                                             │
│ Incompatible Java/Gradle versions.                                          │
│                                                                             │
│ Java Version: 17.0.6, Gradle Version: 7.0.2                                 │
│                                                                             │
│ See the link below for more information:                                    │
│ https://docs.gradle.org/current/userguide/compatibility.html#java           │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
```
Example output if Java/Gradle/Agp are not compatible. 
```

┌─────────────────────────────────────────────────────────────────────────────┐
│ General Info                                                                │
│ [✓] App Name: espresso_example                                              │
│ [✓] Supported Platforms: android                                            │
│ [✓] Is Flutter Package: yes                                                 │
│ [✓] Uses Material Design: yes                                               │
│ [✓] Is Plugin: no                                                           │
│ [✗] Java/Gradle/Android Gradle Plugin: Incompatible Gradle/AGP versions.    │
│                                                                             │
│ Gradle Version: 7.0.2, AGP Version: 7.4.2                                   │
│                                                                             │
│ Update gradle to at least "7.5".                                            │
│ See the link below for more information:                                    │
│ https://developer.android.com/studio/releases/gradle-plugin#updating-gradle │
│                                                                             │
│ Incompatible Java/Gradle versions.                                          │
│                                                                             │
│ Java Version: 17.0.6, Gradle Version: 7.0.2                                 │
│                                                                             │
│ See the link below for more information:                                    │
│ https://docs.gradle.org/current/userguide/compatibility.html#java           │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
```

Commit messages
- Add function to gradle_utils.dart that gets the gradle version from
wrapper or system and add a test for each situation
- Add method to get agp version, add method to validate agp against
gradle version, update documentation, add tests for agp validation.
- Update dart doc for validateGradleAndAgp to describe where the info
came from and corner case behavior, create function to validate java and
gradle and hardcode return to false
- Fill out and test java gradle compatibility function in gradle_utils
- Hook up java gradle evaluateion to hasValidJavaGradleAgpVersions with
hardcoded java version
- Add java --version output parsing and tests
- Add getJavaBinary test
- Update comment in android_sdk for mac behavior with java_home -v

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [x] I signed the [CLA].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [ ] All existing and new tests are passing.

dev/integration_tests/flutter_gallery/android/gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-all.zip

packages/flutter_tools/lib/src/android/android_sdk.dart

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'package:meta/meta.dart';
+
 import '../base/common.dart';
 import '../base/file_system.dart';
 import '../base/os.dart';
@@ -409,6 +411,57 @@ class AndroidSdk {
     return null;
   }
 
+  /// Returns the version of java in the format \d(.\d)+(.\d)+
+  /// Returns null if version not found.
+  String? getJavaVersion({
+    required AndroidStudio? androidStudio,
+    required FileSystem fileSystem,
+    required OperatingSystemUtils operatingSystemUtils,
+    required Platform platform,
+    required ProcessUtils processUtils,
+  }) {
+    final String? javaBinary = findJavaBinary(
+      androidStudio: androidStudio,
+      fileSystem: fileSystem,
+      operatingSystemUtils: operatingSystemUtils,
+      platform: platform,
+    );
+    if (javaBinary == null) {
+      globals.printTrace('Could not find java binary to get version.');
+      return null;
+    }
+    final RunResult result = processUtils.runSync(
+      <String>[javaBinary, '--version'],
+      environment: sdkManagerEnv,
+    );
+    if (result.exitCode != 0) {
+      globals.printTrace(
+          'java --version failed: exitCode: ${result.exitCode} stdout: ${result.stdout} stderr: ${result.stderr}');
+      return null;
+    }
+    return parseJavaVersion(result.stdout);
+  }
+
+  /// Extracts JDK version from the output of java --version.
+  @visibleForTesting
+  static String? parseJavaVersion(String rawVersionOutput) {
+    // The contents that matter come in the format '11.0.18' or '1.8.0_202'.
+    final RegExp jdkVersionRegex = RegExp(r'\d+\.\d+(\.\d+(?:_\d+)?)?');
+    final Iterable<RegExpMatch> matches =
+        jdkVersionRegex.allMatches(rawVersionOutput);
+    if (matches.isEmpty) {
+      globals.logger.printWarning(_formatJavaVersionWarning(rawVersionOutput));
+      return null;
+    }
+    final String? versionString = matches.first.group(0);
+    if (versionString == null || versionString.split('_').isEmpty) {
+      globals.logger.printWarning(_formatJavaVersionWarning(rawVersionOutput));
+      return null;
+    }
+    // Trim away _d+ from versions 1.8 and below.
+    return versionString.split('_').first;
+  }
+
   /// First try Java bundled with Android Studio, then sniff JAVA_HOME, then fallback to PATH.
   static String? findJavaBinary({
     required AndroidStudio? androidStudio,
@@ -417,12 +470,15 @@ class AndroidSdk {
     required Platform platform,
   }) {
     if (androidStudio?.javaPath != null) {
+      globals.printTrace("Using Android Studio's java.");
       return fileSystem.path.join(androidStudio!.javaPath!, 'bin', 'java');
     }
 
-    final String? javaHomeEnv = platform.environment[_javaHomeEnvironmentVariable];
+    final String? javaHomeEnv =
+        platform.environment[_javaHomeEnvironmentVariable];
     if (javaHomeEnv != null) {
       // Trust JAVA_HOME.
+      globals.printTrace('Using JAVA_HOME.');
       return fileSystem.path.join(javaHomeEnv, 'bin', 'java');
     }
 
@@ -430,23 +486,48 @@ class AndroidSdk {
     // See: http://stackoverflow.com/questions/14292698/how-do-i-check-if-the-java-jdk-is-installed-on-mac.
     if (platform.isMacOS) {
       try {
-        final String javaHomeOutput = globals.processUtils.runSync(
-          <String>['/usr/libexec/java_home', '-v', '1.8'],
-          throwOnError: true,
-          hideStdout: true,
-        ).stdout.trim();
+        // -v Filter versions (as if JAVA_VERSION had been set in the environment).
+        // It is unlikley that filtering to java version 1.8 is the right
+        // decision here. That said, trying this on a mac shows the same jdk
+        // path no matter what input is passed.
+        final String javaHomeOutput = globals.processUtils
+            .runSync(
+              <String>['/usr/libexec/java_home', '-v', '1.8'],
+              throwOnError: true,
+              hideStdout: true,
+            )
+            .stdout
+            .trim();
         if (javaHomeOutput.isNotEmpty) {
           final String javaHome = javaHomeOutput.split('\n').last.trim();
+          globals.printTrace('Using mac JAVA_HOME.');
           return fileSystem.path.join(javaHome, 'bin', 'java');
         }
-      } on Exception { /* ignore */ }
+      } on Exception {/* ignore */}
     }
 
     // Fallback to PATH based lookup.
-    return operatingSystemUtils.which(_javaExecutable)?.path;
+    final String? pathJava = operatingSystemUtils.which(_javaExecutable)?.path;
+    if (pathJava != null) {
+      globals.printTrace('Using java from PATH.');
+    } else {
+      globals.printTrace('Could not find java path.');
+    }
+    return pathJava;
+  }
+
+  // Returns a user visible String that says the tool failed to parse
+  // the version of java along with the output.
+  static String _formatJavaVersionWarning(String javaVersionRaw) {
+    return 'Could not parse java version from: \n'
+        '$javaVersionRaw \n'
+        'If there is a version please look for an existing bug '
+        'https://github.com/flutter/flutter/issues/'
+        ' and if one does not exist file a new issue.';
   }
 
   Map<String, String>? _sdkManagerEnv;
+
   /// Returns an environment with the Java folder added to PATH for use in calling
   /// Java-based Android SDK commands such as sdkmanager and avdmanager.
   Map<String, String> get sdkManagerEnv {

packages/flutter_tools/lib/src/base/version.dart

@@ -4,6 +4,7 @@
 
 import 'package:meta/meta.dart';
 
+// TODO(reidbaker): Investigate using pub_semver instead of this class.
 @immutable
 class Version implements Comparable<Version> {
   /// Creates a new [Version] object.
@@ -119,3 +120,35 @@ class Version implements Comparable<Version> {
   @override
   String toString() => _text;
 }
+
+/// Returns true if [targetVersion] is within the range [min] and [max]
+/// inclusive by default.
+///
+/// [min] and [max] are evaluated by [Version.parse(text)].
+///
+/// Pass [inclusiveMin] = false for greater than and not equal to min.
+/// Pass [inclusiveMax] = false for less than and not equal to max.
+bool isWithinVersionRange(
+  String targetVersion, {
+  required String min,
+  required String max,
+  bool inclusiveMax = true,
+  bool inclusiveMin = true,
+}) {
+  final Version? parsedTargetVersion = Version.parse(targetVersion);
+  final Version? minVersion = Version.parse(min);
+  final Version? maxVersion = Version.parse(max);
+
+  final bool withinMin = minVersion != null &&
+      parsedTargetVersion != null &&
+      (inclusiveMin
+      ? parsedTargetVersion >= minVersion
+      : parsedTargetVersion > minVersion);
+
+  final bool withinMax = maxVersion != null &&
+      parsedTargetVersion != null &&
+      (inclusiveMax
+          ? parsedTargetVersion <= maxVersion
+          : parsedTargetVersion < maxVersion);
+  return withinMin && withinMax;
+}

packages/flutter_tools/lib/src/context_runner.dart

@@ -236,7 +236,6 @@ Future<T> runInContext<T>(
         fuchsiaArtifacts: globals.fuchsiaArtifacts!,
       ),
       GradleUtils: () => GradleUtils(
-        fileSystem: globals.fs,
         operatingSystemUtils: globals.os,
         logger: globals.logger,
         platform: globals.platform,

packages/flutter_tools/lib/src/project.dart

@@ -20,6 +20,7 @@ import 'flutter_manifest.dart';
 import 'flutter_plugins.dart';
 import 'globals.dart' as globals;
 import 'platform_plugins.dart';
+import 'project_validator_result.dart';
 import 'reporting/reporting.dart';
 import 'template.dart';
 import 'xcode_project.dart';
@@ -418,6 +419,20 @@ abstract class FlutterProjectPlatform {
 class AndroidProject extends FlutterProjectPlatform {
   AndroidProject._(this.parent);
 
+  // User facing string when java/gradle/agp versions are compatible.
+  @visibleForTesting
+  static const String validJavaGradleAgpString = 'compatible java/gradle/agp';
+
+  // User facing link that describes compatibility between gradle and
+  // android gradle plugin.
+  static const String gradleAgpCompatUrl =
+    'https://developer.android.com/studio/releases/gradle-plugin#updating-gradle';
+
+  // User facing link that describes compatibility between java and the first
+  // version of gradle to support it.
+  static const String javaGradleCompatUrl =
+    'https://docs.gradle.org/current/userguide/compatibility.html#java';
+
   /// The parent of this project.
   final FlutterProject parent;
 
@@ -510,6 +525,77 @@ class AndroidProject extends FlutterProjectPlatform {
     return parent.isModule || _editableHostAppDirectory.existsSync();
   }
 
+  /// Check if the versions of Java, Gradle and AGP are compatible.
+  ///
+  /// This is expected to be called from
+  /// flutter_tools/lib/src/project_validator.dart.
+  Future<ProjectValidatorResult> validateJavaGradleAgpVersions() async {
+    // Constructing ProjectValidatorResult happens here and not in
+    // flutter_tools/lib/src/project_validator.dart because of the additional
+    // Complexity of variable status values and error string formatting.
+    const String visibleName = 'Java/Gradle/Android Gradle Plugin';
+    final CompatibilityResult validJavaGradleAgpVersions =
+        await hasValidJavaGradleAgpVersions();
+
+
+    return ProjectValidatorResult(
+      name: visibleName,
+      value: validJavaGradleAgpVersions.description,
+      status: validJavaGradleAgpVersions.success
+          ? StatusProjectValidator.success
+          : StatusProjectValidator.error,
+    );
+  }
+
+  /// Ensures Java SDK is compatible with the project's Gradle version and
+  /// the project's Gradle version is compatible with the AGP version used
+  /// in build.gradle.
+  Future<CompatibilityResult> hasValidJavaGradleAgpVersions() async {
+    final String? gradleVersion = await gradle.getGradleVersion(
+        hostAppGradleRoot, globals.logger, globals.processManager);
+    final String? agpVersion =
+        gradle.getAgpVersion(hostAppGradleRoot, globals.logger);
+    final String? javaVersion = globals.androidSdk?.getJavaVersion(
+      androidStudio: globals.androidStudio,
+      fileSystem: globals.fs,
+      operatingSystemUtils: globals.os,
+      platform: globals.platform,
+      processUtils: globals.processUtils,
+    );
+
+    // Assume valid configuration.
+    String description = validJavaGradleAgpString;
+
+    final bool compatibleGradleAgp = gradle.validateGradleAndAgp(globals.logger,
+        gradleV: gradleVersion, agpV: agpVersion);
+
+    final bool compatibleJavaGradle = gradle.validateJavaGradle(globals.logger,
+        javaV: javaVersion, gradleV: gradleVersion);
+
+    // Begin description formatting.
+    if (!compatibleGradleAgp) {
+      description = '''
+Incompatible Gradle/AGP versions. \n
+Gradle Version: $gradleVersion, AGP Version: $agpVersion
+Update Gradle to at least "${gradle.getGradleVersionFor(agpVersion!)}".\n
+See the link below for more information:
+$gradleAgpCompatUrl
+''';
+    }
+    if (!compatibleJavaGradle) {
+      // Should contain the agp error (if present) but not the valid String.
+      description = '''
+${compatibleGradleAgp ? '' : description}
+Incompatible Java/Gradle versions.
+Java Version: $javaVersion, Gradle Version: $gradleVersion\n
+See the link below for more information:
+$javaGradleCompatUrl
+''';
+    }
+    return CompatibilityResult(
+        compatibleJavaGradle && compatibleGradleAgp, description);
+  }
+
   bool get isUsingGradle {
     return hostAppGradleRoot.childFile('build.gradle').existsSync();
   }
@@ -570,12 +656,17 @@ class AndroidProject extends FlutterProjectPlatform {
 
   Future<void> _regenerateLibrary() async {
     ErrorHandlingFileSystem.deleteIfExists(ephemeralDirectory, recursive: true);
+    await _overwriteFromTemplate(
+        globals.fs.path.join(
+          'module',
+          'android',
+          'library_new_embedding',
+        ),
+        ephemeralDirectory);
     await _overwriteFromTemplate(globals.fs.path.join(
       'module',
       'android',
-      'library_new_embedding',
-    ), ephemeralDirectory);
-    await _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'gradle'), ephemeralDirectory);
+      'gradle'), ephemeralDirectory);
     globals.gradleUtils?.injectGradleWrapperIfNeeded(ephemeralDirectory);
   }
 
@@ -786,3 +877,12 @@ class FuchsiaProject {
   Directory get meta =>
       _meta ??= editableHostAppDirectory.childDirectory('meta');
 }
+
+// Combines success and a description into one object that can be returned
+// together.
+@visibleForTesting
+class CompatibilityResult {
+  CompatibilityResult(this.success, this.description);
+  final bool success;
+  final String description;
+}

packages/flutter_tools/lib/src/project_validator.dart

@@ -224,6 +224,7 @@ class GeneralInfoProjectValidator extends ProjectValidator{
       result.add(_materialDesignResult(flutterManifest));
       result.add(_pluginValidatorResult(flutterManifest));
     }
+    result.add(await project.android.validateJavaGradleAgpVersions());
     return result;
   }
 

packages/flutter_tools/test/general.shard/android/android_sdk_test.dart

@@ -4,13 +4,18 @@
 
 import 'package:file/memory.dart';
 import 'package:flutter_tools/src/android/android_sdk.dart';
+import 'package:flutter_tools/src/android/android_studio.dart';
 import 'package:flutter_tools/src/base/config.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/logger.dart';
 import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/base/process.dart';
 import 'package:flutter_tools/src/globals.dart' as globals;
 
+import '../../integration.shard/test_utils.dart';
 import '../../src/common.dart';
 import '../../src/context.dart';
+import '../../src/fakes.dart' show FakeAndroidStudio, FakeOperatingSystemUtils;
 
 void main() {
   late MemoryFileSystem fileSystem;
@@ -342,6 +347,132 @@ void main() {
       Config: () => config,
     });
   });
+
+  group('java version', () {
+    const String exampleJdk8Output = '''
+java version "1.8.0_202"
+Java(TM) SE Runtime Environment (build 1.8.0_202-b10)
+Java HotSpot(TM) 64-Bit Server VM (build 25.202-b10, mixed mode)
+''';
+    // Example strings came from actual terminal output.
+    testWithoutContext('parses jdk 8', () {
+      expect(AndroidSdk.parseJavaVersion(exampleJdk8Output), '1.8.0');
+    });
+
+    testWithoutContext('parses jdk 11 windows', () {
+      const String exampleJdkOutput = '''
+java version "11.0.14"
+Java(TM) SE Runtime Environment (build 11.0.14+10-b13)
+Java HotSpot(TM) 64-Bit Server VM (build 11.0.14+10-b13, mixed mode)
+''';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '11.0.14');
+    });
+
+    testWithoutContext('parses jdk 11 mac/linux', () {
+      const String exampleJdkOutput = '''
+openjdk version "11.0.18" 2023-01-17 LTS
+OpenJDK Runtime Environment Zulu11.62+17-CA (build 11.0.18+10-LTS)
+OpenJDK 64-Bit Server VM Zulu11.62+17-CA (build 11.0.18+10-LTS, mixed mode)
+''';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '11.0.18');
+    });
+
+    testWithoutContext('parses jdk 17', () {
+      const String exampleJdkOutput = '''
+openjdk 17.0.6 2023-01-17
+OpenJDK Runtime Environment (build 17.0.6+0-17.0.6b802.4-9586694)
+OpenJDK 64-Bit Server VM (build 17.0.6+0-17.0.6b802.4-9586694, mixed mode)
+''';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '17.0.6');
+    });
+
+    testWithoutContext('parses jdk 19', () {
+      const String exampleJdkOutput = '''
+openjdk 19.0.2 2023-01-17
+OpenJDK Runtime Environment Homebrew (build 19.0.2)
+OpenJDK 64-Bit Server VM Homebrew (build 19.0.2, mixed mode, sharing)
+''';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '19.0.2');
+    });
+
+    // https://chrome-infra-packages.appspot.com/p/flutter/java/openjdk/
+    testWithoutContext('parses jdk output from ci', () {
+      const String exampleJdkOutput = '''
+openjdk 11.0.2 2019-01-15
+OpenJDK Runtime Environment 18.9 (build 11.0.2+9)
+OpenJDK 64-Bit Server VM 18.9 (build 11.0.2+9, mixed mode)
+''';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '11.0.2');
+    });
+
+    testWithoutContext('parses jdk two number versions', () {
+      const String exampleJdkOutput = 'openjdk 19.0 2023-01-17';
+      expect(AndroidSdk.parseJavaVersion(exampleJdkOutput), '19.0');
+    });
+
+    testUsingContext('getJavaBinary with AS install', () {
+      final Directory sdkDir = createSdkDirectory(fileSystem: fileSystem);
+      config.setValue('android-sdk', sdkDir.path);
+      final AndroidStudio androidStudio = FakeAndroidStudio();
+
+      final String javaPath = AndroidSdk.findJavaBinary(
+          androidStudio: androidStudio,
+          fileSystem: fileSystem,
+          operatingSystemUtils: FakeOperatingSystemUtils(),
+          platform: platform)!;
+      // Built from the implementation of findJavaBinary android studio case.
+      final String expectedJavaPath = '${androidStudio.javaPath}/bin/java';
+
+      expect(javaPath, expectedJavaPath);
+    }, overrides: <Type, Generator>{
+      FileSystem: () => fileSystem,
+      ProcessManager: () => processManager,
+      Config: () => config,
+      Platform: () => FakePlatform(environment: <String, String>{}),
+    });
+
+    group('java', () {
+      late AndroidStudio androidStudio;
+      setUp(() {
+        androidStudio = FakeAndroidStudio();
+      });
+      testUsingContext('getJavaVersion finds AS java and parses version', () {
+        final Directory sdkDir = createSdkDirectory(fileSystem: fileSystem);
+        config.setValue('android-sdk', sdkDir.path);
+
+        final ProcessUtils processUtils = ProcessUtils(
+            processManager: processManager, logger: BufferLogger.test());
+        // Built from the implementation of findJavaBinary android studio case.
+        final String expectedJavaPath = '${androidStudio.javaPath}/bin/java';
+
+        processManager.addCommand(FakeCommand(
+          command: <String>[
+            expectedJavaPath,
+            '--version',
+          ],
+          stdout: exampleJdk8Output,
+        ));
+
+        final AndroidSdk sdk = AndroidSdk.locateAndroidSdk()!;
+
+        final String? javaVersion = sdk.getJavaVersion(
+          androidStudio: androidStudio,
+          fileSystem: fileSystem,
+          operatingSystemUtils: FakeOperatingSystemUtils(),
+          platform: FakePlatform(),
+          processUtils: processUtils,
+        );
+
+        expect(javaVersion, '1.8.0');
+      }, overrides: <Type, Generator>{
+        FileSystem: () => fileSystem,
+        ProcessManager: () => processManager,
+        AndroidStudio: () => androidStudio,
+        Config: () => config,
+        Platform: () => FakePlatform(environment: <String, String>{}),
+      });
+    });
+  });
 }
 
 /// A broken SDK installation.

packages/flutter_tools/test/general.shard/android/android_workflow_test.dart

@@ -16,6 +16,7 @@ import 'package:flutter_tools/src/doctor_validator.dart';
 import 'package:test/fake.dart';
 
 import '../../src/common.dart';
+import '../../src/context.dart';
 import '../../src/fake_process_manager.dart';
 import '../../src/fakes.dart';
 
@@ -425,7 +426,7 @@ Review licenses that have not been accepted (y/N)?
     expect(licenseMessage.message, UserMessages().androidSdkLicenseOnly(kAndroidHome));
   });
 
-  testWithoutContext('detects minimum required SDK and buildtools', () async {
+  testUsingContext('detects minimum required SDK and buildtools', () async {
     processManager.addCommand(const FakeCommand(
       command: <String>[
         'which',
@@ -523,7 +524,7 @@ Review licenses that have not been accepted (y/N)?
     expect(cmdlineMessage.message, errorMessage);
   });
 
-  testWithoutContext('detects minimum required java version', () async {
+  testUsingContext('detects minimum required java version', () async {
     // Test with older version of JDK
     const String javaVersionText = 'openjdk version "1.7.0_212"';
     processManager.addCommand(const FakeCommand(

packages/flutter_tools/test/general.shard/android/gradle_test.dart

@@ -5,7 +5,7 @@
 import 'package:file/memory.dart';
 import 'package:flutter_tools/src/android/android_sdk.dart';
 import 'package:flutter_tools/src/android/gradle.dart';
-import 'package:flutter_tools/src/android/gradle_utils.dart';
+import 'package:flutter_tools/src/android/gradle_utils.dart' as gradle_utils;
 import 'package:flutter_tools/src/artifacts.dart';
 import 'package:flutter_tools/src/base/common.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
@@ -196,7 +196,7 @@ void main() {
   group('gradle build', () {
     testUsingContext('do not crash if there is no Android SDK', () async {
       expect(() {
-        updateLocalProperties(project: FlutterProject.fromDirectoryTest(globals.fs.currentDirectory));
+        gradle_utils.updateLocalProperties(project: FlutterProject.fromDirectoryTest(globals.fs.currentDirectory));
       }, throwsToolExit(
         message: '${globals.logger.terminal.warningMark} No Android SDK found. Try setting the ANDROID_SDK_ROOT environment variable.',
       ));
@@ -241,7 +241,7 @@ void main() {
       manifestFile.writeAsStringSync(manifest);
 
 
-      updateLocalProperties(
+      gradle_utils.updateLocalProperties(
         project: FlutterProject.fromDirectoryTest(globals.fs.directory('path/to/project')),
         buildInfo: buildInfo,
         requireAndroidSdk: false,
@@ -415,55 +415,57 @@ flutter:
     });
   });
 
-  group('gradle version', () {
+  group('gradgradle_utils.le version', () {
     testWithoutContext('should be compatible with the Android plugin version', () {
-      // Granular versions.
-      expect(getGradleVersionFor('1.0.0'), '2.3');
-      expect(getGradleVersionFor('1.0.1'), '2.3');
-      expect(getGradleVersionFor('1.0.2'), '2.3');
-      expect(getGradleVersionFor('1.0.4'), '2.3');
-      expect(getGradleVersionFor('1.0.8'), '2.3');
-      expect(getGradleVersionFor('1.1.0'), '2.3');
-      expect(getGradleVersionFor('1.1.2'), '2.3');
-      expect(getGradleVersionFor('1.1.2'), '2.3');
-      expect(getGradleVersionFor('1.1.3'), '2.3');
-      // Version Ranges.
-      expect(getGradleVersionFor('1.2.0'), '2.9');
-      expect(getGradleVersionFor('1.3.1'), '2.9');
+      // Grangradle_utils.ular versions.
+      expect(gradle_utils.getGradleVersionFor('1.0.0'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.0.1'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.0.2'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.0.4'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.0.8'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.1.0'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.1.2'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.1.2'), '2.3');
+      expect(gradle_utils.getGradleVersionFor('1.1.3'), '2.3');
+      // Versgradle_utils.ion Ranges.
+      expect(gradle_utils.getGradleVersionFor('1.2.0'), '2.9');
+      expect(gradle_utils.getGradleVersionFor('1.3.1'), '2.9');
 
-      expect(getGradleVersionFor('1.5.0'), '2.2.1');
+      expect(gradle_utils.getGradleVersionFor('1.5.0'), '2.2.1');
 
-      expect(getGradleVersionFor('2.0.0'), '2.13');
-      expect(getGradleVersionFor('2.1.2'), '2.13');
+      expect(gradle_utils.getGradleVersionFor('2.0.0'), '2.13');
+      expect(gradle_utils.getGradleVersionFor('2.1.2'), '2.13');
 
-      expect(getGradleVersionFor('2.1.3'), '2.14.1');
-      expect(getGradleVersionFor('2.2.3'), '2.14.1');
+      expect(gradle_utils.getGradleVersionFor('2.1.3'), '2.14.1');
+      expect(gradle_utils.getGradleVersionFor('2.2.3'), '2.14.1');
 
-      expect(getGradleVersionFor('2.3.0'), '3.3');
+      expect(gradle_utils.getGradleVersionFor('2.3.0'), '3.3');
 
-      expect(getGradleVersionFor('3.0.0'), '4.1');
+      expect(gradle_utils.getGradleVersionFor('3.0.0'), '4.1');
 
-      expect(getGradleVersionFor('3.1.0'), '4.4');
+      expect(gradle_utils.getGradleVersionFor('3.1.0'), '4.4');
 
-      expect(getGradleVersionFor('3.2.0'), '4.6');
-      expect(getGradleVersionFor('3.2.1'), '4.6');
+      expect(gradle_utils.getGradleVersionFor('3.2.0'), '4.6');
+      expect(gradle_utils.getGradleVersionFor('3.2.1'), '4.6');
 
-      expect(getGradleVersionFor('3.3.0'), '4.10.2');
-      expect(getGradleVersionFor('3.3.2'), '4.10.2');
+      expect(gradle_utils.getGradleVersionFor('3.3.0'), '4.10.2');
+      expect(gradle_utils.getGradleVersionFor('3.3.2'), '4.10.2');
 
-      expect(getGradleVersionFor('3.4.0'), '5.6.2');
-      expect(getGradleVersionFor('3.5.0'), '5.6.2');
+      expect(gradle_utils.getGradleVersionFor('3.4.0'), '5.6.2');
+      expect(gradle_utils.getGradleVersionFor('3.5.0'), '5.6.2');
 
-      expect(getGradleVersionFor('4.0.0'), '6.7');
-      expect(getGradleVersionFor('4.1.0'), '6.7');
+      expect(gradle_utils.getGradleVersionFor('4.0.0'), '6.7');
+      expect(gradle_utils.getGradleVersionFor('4.1.0'), '6.7');
 
-      expect(getGradleVersionFor('7.0'), '7.5');
-      expect(getGradleVersionFor('7.1.2'), '7.5');
-      expect(getGradleVersionFor('7.2'), '7.5');
+      expect(gradle_utils.getGradleVersionFor('7.0'), '7.5');
+      expect(gradle_utils.getGradleVersionFor('7.1.2'), '7.5');
+      expect(gradle_utils.getGradleVersionFor('7.2'), '7.5');
+      expect(gradle_utils.getGradleVersionFor('8.0'), '8.0');
+      expect(gradle_utils.getGradleVersionFor(gradle_utils.maxKnownAgpVersion), '8.0');
     });
 
     testWithoutContext('throws on unsupported versions', () {
-      expect(() => getGradleVersionFor('3.6.0'),
+      expect(() => gradle_utils.getGradleVersionFor('3.6.0'),
           throwsA(predicate<Exception>((Exception e) => e is ToolExit)));
     });
   });

packages/flutter_tools/test/general.shard/utils_test.dart

@@ -56,6 +56,57 @@ baz=qux
 
       expect(Version.parse('Preview2.2'), isNull);
     });
+
+    group('isWithinVersionRange', () {
+      test('unknown not included', () {
+        expect(isWithinVersionRange('unknown', min: '1.0.0', max: '1.1.3'),
+            isFalse);
+      });
+
+      test('pre java 8 format included', () {
+        expect(isWithinVersionRange('1.0.0_201', min: '1.0.0', max: '1.1.3'),
+            isTrue);
+      });
+
+      test('min included by default', () {
+        expect(
+            isWithinVersionRange('1.0.0', min: '1.0.0', max: '1.1.3'), isTrue);
+      });
+
+      test('max included by default', () {
+        expect(
+            isWithinVersionRange('1.1.3', min: '1.0.0', max: '1.1.3'), isTrue);
+      });
+
+      test('inclusive min excluded', () {
+        expect(
+            isWithinVersionRange('1.0.0',
+                min: '1.0.0', max: '1.1.3', inclusiveMin: false),
+            isFalse);
+      });
+
+      test('inclusive max excluded', () {
+        expect(
+            isWithinVersionRange('1.1.3',
+                min: '1.0.0', max: '1.1.3', inclusiveMax: false),
+            isFalse);
+      });
+
+      test('lower value excluded', () {
+        expect(
+            isWithinVersionRange('0.1.0', min: '1.0.0', max: '1.1.3'), isFalse);
+      });
+
+      test('higher value excluded', () {
+        expect(
+            isWithinVersionRange('1.1.4', min: '1.0.0', max: '1.1.3'), isFalse);
+      });
+
+      test('middle value included', () {
+        expect(
+            isWithinVersionRange('1.1.0', min: '1.0.0', max: '1.1.3'), isTrue);
+      });
+    });
   });
 
   group('Misc', () {

packages/flutter_tools/test/integration.shard/analyze_suggestions_integration_test.dart

@@ -11,6 +11,7 @@ import 'package:flutter_tools/src/base/logger.dart';
 import 'package:flutter_tools/src/base/platform.dart';
 import 'package:flutter_tools/src/commands/analyze.dart';
 import 'package:flutter_tools/src/globals.dart' as globals;
+import 'package:flutter_tools/src/project.dart';
 import 'package:flutter_tools/src/project_validator.dart';
 
 import '../src/common.dart';
@@ -57,6 +58,7 @@ void main() {
       '│ [✓] Is Flutter Package: yes                                       │\n'
       '│ [✓] Uses Material Design: yes                                     │\n'
       '│ [✓] Is Plugin: no                                                 │\n'
+      '│ [✓] Java/Gradle/Android Gradle Plugin: ${AndroidProject.validJavaGradleAgpString} │\n'
       '└───────────────────────────────────────────────────────────────────┘\n';
 
       expect(loggerTest.statusText, contains(expected));

packages/flutter_tools/test/src/fakes.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:io' as io show IOSink, ProcessSignal, Stdout, StdoutException;
 
 import 'package:flutter_tools/src/android/android_sdk.dart';
+import 'package:flutter_tools/src/android/android_studio.dart';
 import 'package:flutter_tools/src/base/bot_detector.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
 import 'package:flutter_tools/src/base/io.dart';
@@ -596,3 +597,8 @@ class FakeAndroidSdk extends Fake implements AndroidSdk {
   @override
   AndroidSdkVersion? latestVersion;
 }
+
+class FakeAndroidStudio extends Fake implements AndroidStudio {
+  @override
+  String get javaPath => 'java';
+}