[flutter_tools] disable flutter build AAR for plugins (#137878)

Per discord discussion, building an AAR out of a plugin project has not worked for years, so let's just disable the functionality. Context: https://github.com/flutter/flutter/issues/137564

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

@@ -656,10 +656,9 @@ class AndroidGradleBuilder implements AndroidBuilder {
     required Directory outputDirectory,
     required String buildNumber,
   }) async {
-
     final FlutterManifest manifest = project.manifest;
-    if (!manifest.isModule && !manifest.isPlugin) {
-      throwToolExit('AARs can only be built for plugin or module projects.');
+    if (!manifest.isModule) {
+      throwToolExit('AARs can only be built for module projects.');
     }
 
     final BuildInfo buildInfo = androidBuildInfo.buildInfo;

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

@@ -17,7 +17,6 @@ const String _javaExecutable = 'java';
 
 /// Represents an installation of Java.
 class Java {
-
   Java({
     required this.javaHome,
     required this.binaryPath,

packages/flutter_tools/lib/src/commands/build_aar.dart

@@ -75,14 +75,14 @@ class BuildAarCommand extends BuildSubCommand {
     DevelopmentArtifact.androidGenSnapshot,
   };
 
+  late final FlutterProject project = _getProject();
+
   @override
   Future<CustomDimensions> get usageValues async {
-    final FlutterProject flutterProject = _getProject();
-
-    String projectType;
-    if (flutterProject.manifest.isModule) {
+    final String projectType;
+    if (project.manifest.isModule) {
       projectType = 'module';
-    } else if (flutterProject.manifest.isPlugin) {
+    } else if (project.manifest.isPlugin) {
       projectType = 'plugin';
     } else {
       projectType = 'app';
@@ -102,6 +102,14 @@ class BuildAarCommand extends BuildSubCommand {
       'This command assumes that the entrypoint is "lib/main.dart". '
       'This cannot currently be configured.';
 
+  @override
+  Future<void> validateCommand() async {
+    if (!project.manifest.isModule) {
+      throwToolExit('AARs can only be built from modules.');
+    }
+    await super.validateCommand();
+  }
+
   @override
   Future<FlutterCommandResult> runCommand() async {
     if (_androidSdk == null) {
@@ -139,7 +147,7 @@ class BuildAarCommand extends BuildSubCommand {
 
     displayNullSafetyMode(androidBuildInfo.first.buildInfo);
     await androidBuilder?.buildAar(
-      project: _getProject(),
+      project: project,
       target: targetFile.path,
       androidBuildInfo: androidBuildInfo,
       outputDirectoryPath: stringArg('output'),

packages/flutter_tools/test/commands.shard/hermetic/build_aar_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/artifacts.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/build_system/build_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/fake_process_manager.dart';
+import '../../src/fakes.dart';
+import '../../src/test_build_system.dart';
+import '../../src/test_flutter_command_runner.dart';
+
+void main() {
+  late BufferLogger logger;
+  late MemoryFileSystem fs;
+  late Artifacts artifacts;
+  late FakeProcessManager processManager;
+  late Platform platform;
+  late Cache cache;
+
+  setUpAll(() {
+    Cache.disableLocking();
+  });
+
+  setUp(() {
+    fs = MemoryFileSystem.test();
+    final Directory flutterRoot = fs.directory('flutter');
+    Cache.flutterRoot = flutterRoot.path;
+    artifacts = Artifacts.test(fileSystem: fs);
+    logger = BufferLogger.test();
+    platform = FakePlatform(environment: const <String, String>{'PATH': ''});
+    processManager = FakeProcessManager.empty();
+    cache = Cache.test(
+      rootOverride: flutterRoot,
+      logger: logger,
+      processManager: processManager,
+    );
+  });
+
+  testUsingContext('will not build an AAR for a plugin', () async {
+    fs.file('pubspec.yaml').writeAsStringSync('''
+name: foo_bar
+
+flutter:
+  plugin:
+    platforms:
+      some_platform:
+        null
+''');
+
+    final BuildCommand command = BuildCommand(
+      androidSdk: FakeAndroidSdk(),
+      artifacts: artifacts,
+      buildSystem: TestBuildSystem.all(BuildResult(success: true)),
+      fileSystem: fs,
+      logger: logger,
+      osUtils: FakeOperatingSystemUtils(),
+      processUtils: ProcessUtils(
+        logger: logger,
+        processManager: processManager,
+      ),
+    );
+
+    expect(
+      createTestCommandRunner(command).run(const <String>['build', 'aar', '--no-pub']),
+      throwsToolExit(message: 'AARs can only be built from modules'),
+    );
+    expect(processManager, hasNoRemainingExpectations);
+  }, overrides: <Type, Generator>{
+    Cache: () => cache,
+    FileSystem: () => fs,
+    Platform: () => platform,
+    ProcessManager: () => processManager,
+  });
+
+  testUsingContext('will build an AAR for a module', () async {
+    fs.file('pubspec.yaml').writeAsStringSync('''
+name: foo_bar
+
+flutter:
+  module:
+    foo: bar
+''');
+    final Directory dotAndroidDir = fs.directory('.android')..createSync(recursive: true);
+    dotAndroidDir.childFile('gradlew').createSync();
+
+    processManager.addCommands(<FakeCommand>[
+      const FakeCommand(command: <String>['chmod', '755', 'flutter/bin/cache/artifacts']),
+      const FakeCommand(command: <String>['which', 'java']),
+      ...<String>['Debug', 'Profile', 'Release'].map((String buildMode) => FakeCommand(
+        command: <Pattern>[
+          '/.android/gradlew',
+          '-I=/flutter/packages/flutter_tools/gradle/aar_init_script.gradle',
+          ...List<RegExp>.filled(4, RegExp(r'-P[a-zA-Z-]+=.*')),
+          '-q',
+          ...List<RegExp>.filled(5, RegExp(r'-P[a-zA-Z-]+=.*')),
+          'assembleAar$buildMode',
+        ],
+        onRun: () => fs.directory('/build/host/outputs/repo').createSync(recursive: true),
+      )),
+    ]);
+
+    cache.getArtifactDirectory('gradle_wrapper').createSync(recursive: true);
+
+    final BuildCommand command = BuildCommand(
+      androidSdk: FakeAndroidSdk(),
+      artifacts: artifacts,
+      buildSystem: TestBuildSystem.all(BuildResult(success: true)),
+      fileSystem: fs,
+      logger: logger,
+      osUtils: FakeOperatingSystemUtils(),
+      processUtils: ProcessUtils(
+        logger: logger,
+        processManager: processManager,
+      ),
+    );
+
+    await createTestCommandRunner(command).run(const <String>['build', 'aar', '--no-pub']);
+    expect(processManager, hasNoRemainingExpectations);
+  }, overrides: <Type, Generator>{
+    FileSystem: () => fs,
+    Platform: () => platform,
+    ProcessManager: () => processManager,
+  });
+}

packages/flutter_tools/test/commands.shard/permeable/build_aar_test.dart

@@ -69,17 +69,6 @@ void main() {
       AndroidBuilder: () => FakeAndroidBuilder(),
     });
 
-    testUsingContext('indicate that project is a plugin', () async {
-      final String projectPath = await createProject(tempDir,
-          arguments: <String>['--no-pub', '--template=plugin', '--project-name=aar_test']);
-
-      final BuildAarCommand command = await runCommandIn(projectPath);
-      expect((await command.usageValues).commandBuildAarProjectType, 'plugin');
-
-    }, overrides: <Type, Generator>{
-      AndroidBuilder: () => FakeAndroidBuilder(),
-    });
-
     testUsingContext('indicate the target platform', () async {
       final String projectPath = await createProject(tempDir,
           arguments: <String>['--no-pub', '--template=module']);
@@ -128,7 +117,7 @@ void main() {
 
     testUsingContext('defaults', () async {
       final String projectPath = await createProject(tempDir,
-        arguments: <String>['--no-pub']);
+        arguments: <String>['--no-pub', '--template=module']);
       await runCommandIn(projectPath);
 
       expect(fakeAndroidBuilder.buildNumber, '1.0');
@@ -158,7 +147,7 @@ void main() {
 
     testUsingContext('parses flags', () async {
       final String projectPath = await createProject(tempDir,
-        arguments: <String>['--no-pub']);
+        arguments: <String>['--no-pub', '--template=module']);
       await runCommandIn(
         projectPath,
         arguments: <String>[