Add to app measurement (#33458)

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

@@ -26,6 +26,7 @@ import '../resident_runner.dart';
 import '../run_cold.dart';
 import '../run_hot.dart';
 import '../runner/flutter_command.dart';
+import '../usage.dart';
 
 /// A Flutter-command that attaches to applications that have been launched
 /// without `flutter run`.
@@ -315,8 +316,12 @@ class AttachCommand extends FlutterCommand {
         result = await runner.attach();
         assert(result != null);
       }
-      if (result != 0)
+      if (result == 0) {
+        flutterUsage.sendEvent('attach', 'success');
+      } else {
+        flutterUsage.sendEvent('attach', 'failure');
         throwToolExit(null, exitCode: result);
+      }
     } finally {
       final List<ForwardedPort> ports = device.portForwarder.forwardedPorts.toList();
       for (ForwardedPort port in ports) {

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

@@ -24,6 +24,7 @@ import '../globals.dart';
 import '../project.dart';
 import '../runner/flutter_command.dart';
 import '../template.dart';
+import '../usage.dart';
 import '../version.dart';
 
 enum _ProjectType {
@@ -148,6 +149,15 @@ class CreateCommand extends FlutterCommand {
   @override
   String get invocation => '${runner.executableName} $name <output directory>';
 
+  @override
+  Future<Map<String, String>> get usageValues async {
+    return <String, String>{
+      kCommandCreateProjectType: argResults['template'],
+      kCommandCreateAndroidLanguage: argResults['android-language'],
+      kCommandCreateIosLanguage: argResults['ios-language'],
+    };
+  }
+
   // If it has a .metadata file with the project_type in it, use that.
   // If it has an android dir and an android/app dir, it's a legacy app
   // If it has an ios dir and an ios/Flutter dir, it's a legacy app
@@ -228,6 +238,36 @@ class CreateCommand extends FlutterCommand {
     }
   }
 
+  _ProjectType _getProjectType(Directory projectDir) {
+    _ProjectType template;
+    _ProjectType detectedProjectType;
+    final bool metadataExists = projectDir.absolute.childFile('.metadata').existsSync();
+    if (argResults['template'] != null) {
+      template = _stringToProjectType(argResults['template']);
+    } else {
+      // If the project directory exists and isn't empty, then try to determine the template
+      // type from the project directory.
+      if (projectDir.existsSync() && projectDir.listSync().isNotEmpty) {
+        detectedProjectType = _determineTemplateType(projectDir);
+        if (detectedProjectType == null && metadataExists) {
+          // We can only be definitive that this is the wrong type if the .metadata file
+          // exists and contains a type that we don't understand, or doesn't contain a type.
+          throwToolExit('Sorry, unable to detect the type of project to recreate. '
+              'Try creating a fresh project and migrating your existing code to '
+              'the new project manually.');
+        }
+      }
+    }
+    template ??= detectedProjectType ?? _ProjectType.app;
+    if (detectedProjectType != null && template != detectedProjectType && metadataExists) {
+      // We can only be definitive that this is the wrong type if the .metadata file
+      // exists and contains a type that doesn't match.
+      throwToolExit("The requested template type '${getEnumName(template)}' doesn't match the "
+          "existing template type of '${getEnumName(detectedProjectType)}'.");
+    }
+    return template;
+  }
+
   @override
   Future<FlutterCommandResult> runCommand() async {
     if (argResults['list-samples'] != null) {
@@ -283,31 +323,7 @@ class CreateCommand extends FlutterCommand {
       sampleCode = await _fetchSampleFromServer(argResults['sample']);
     }
 
-    _ProjectType template;
-    _ProjectType detectedProjectType;
-    final bool metadataExists = projectDir.absolute.childFile('.metadata').existsSync();
-    if (argResults['template'] != null) {
-      template = _stringToProjectType(argResults['template']);
-    } else {
-      if (projectDir.existsSync() && projectDir.listSync().isNotEmpty) {
-        detectedProjectType = _determineTemplateType(projectDir);
-        if (detectedProjectType == null && metadataExists) {
-          // We can only be definitive that this is the wrong type if the .metadata file
-          // exists and contains a type that we don't understand, or doesn't contain a type.
-          throwToolExit('Sorry, unable to detect the type of project to recreate. '
-              'Try creating a fresh project and migrating your existing code to '
-              'the new project manually.');
-        }
-      }
-    }
-    template ??= detectedProjectType ?? _ProjectType.app;
-    if (detectedProjectType != null && template != detectedProjectType && metadataExists) {
-      // We can only be definitive that this is the wrong type if the .metadata file
-      // exists and contains a type that doesn't match.
-      throwToolExit("The requested template type '${getEnumName(template)}' doesn't match the "
-          "existing template type of '${getEnumName(detectedProjectType)}'.");
-    }
-
+    final _ProjectType template = _getProjectType(projectDir);
     final bool generateModule = template == _ProjectType.module;
     final bool generatePlugin = template == _ProjectType.plugin;
     final bool generatePackage = template == _ProjectType.package;

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

@@ -9,6 +9,7 @@ import '../base/os.dart';
 import '../dart/pub.dart';
 import '../project.dart';
 import '../runner/flutter_command.dart';
+import '../usage.dart';
 
 class PackagesCommand extends FlutterCommand {
   PackagesCommand() {
@@ -68,13 +69,44 @@ class PackagesGetCommand extends FlutterCommand {
     return '${runner.executableName} pub $name [<target directory>]';
   }
 
-  Future<void> _runPubGet (String directory) async {
-    await pubGet(context: PubContext.pubGet,
-      directory: directory,
-      upgrade: upgrade ,
-      offline: argResults['offline'],
-      checkLastModified: false,
-    );
+  @override
+  Future<Map<String, String>> get usageValues async {
+    final Map<String, String> usageValues = <String, String>{};
+    final String workingDirectory = argResults.rest.length == 1 ? argResults.rest[0] : null;
+    final String target = findProjectRoot(workingDirectory);
+    if (target == null) {
+      return usageValues;
+    }
+    final FlutterProject rootProject = FlutterProject.fromPath(target);
+    final bool hasPlugins = await rootProject.flutterPluginsFile.exists();
+    if (hasPlugins) {
+      final int numberOfPlugins = (await rootProject.flutterPluginsFile.readAsLines()).length;
+      usageValues[kCommandPackagesNumberPlugins] = '$numberOfPlugins';
+    } else {
+      usageValues[kCommandPackagesNumberPlugins] = '0';
+    }
+    usageValues[kCommandPackagesProjectModule] = '${rootProject.isModule}';
+    return usageValues;
+  }
+
+  Future<void> _runPubGet(String directory) async {
+    final Stopwatch pubGetTimer = Stopwatch()..start();
+    try {
+      await pubGet(context: PubContext.pubGet,
+        directory: directory,
+        upgrade: upgrade ,
+        offline: argResults['offline'],
+        checkLastModified: false,
+      );
+      pubGetTimer.stop();
+      flutterUsage.sendEvent('packages-pub-get', 'success');
+      flutterUsage.sendTiming('packages-pub-get', 'success', pubGetTimer.elapsed);
+    } catch (_) {
+      pubGetTimer.stop();
+      flutterUsage.sendEvent('packages-pub-get', 'failure');
+      flutterUsage.sendTiming('packages-pub-get', 'failure', pubGetTimer.elapsed);
+      rethrow;
+    }
   }
 
   @override
@@ -82,13 +114,12 @@ class PackagesGetCommand extends FlutterCommand {
     if (argResults.rest.length > 1)
       throwToolExit('Too many arguments.\n$usage');
 
-    final String target = findProjectRoot(
-      argResults.rest.length == 1 ? argResults.rest[0] : null
-    );
+    final String workingDirectory = argResults.rest.length == 1 ? argResults.rest[0] : null;
+    final String target = findProjectRoot(workingDirectory);
     if (target == null) {
       throwToolExit(
        'Expected to find project root in '
-       '${ argResults.rest.length == 1 ? argResults.rest[0] : "current working directory" }.'
+       '${ workingDirectory ?? "current working directory" }.'
       );
     }
 

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

@@ -19,6 +19,7 @@ import '../run_cold.dart';
 import '../run_hot.dart';
 import '../runner/flutter_command.dart';
 import '../tracing.dart';
+import '../usage.dart';
 import 'daemon.dart';
 
 abstract class RunCommandBase extends FlutterCommand with DeviceBasedDevelopmentArtifacts {
@@ -208,8 +209,23 @@ class RunCommand extends RunCommandBase {
     final String deviceType = devices.length == 1
             ? getNameForTargetPlatform(await devices[0].targetPlatform)
             : 'multiple';
+    final AndroidProject androidProject = FlutterProject.current().android;
+    final IosProject iosProject = FlutterProject.current().ios;
+    final List<String> hostLanguage = <String>[];
 
-    return <String, String>{'cd3': '$isEmulator', 'cd4': deviceType};
+    if (androidProject != null && androidProject.existsSync()) {
+      hostLanguage.add(androidProject.isKotlin ? 'kotlin' : 'java');
+    }
+    if (iosProject != null && iosProject.exists) {
+      hostLanguage.add(iosProject.isSwift ? 'swift' : 'objc');
+    }
+
+    return <String, String>{
+      kCommandRunIsEmulator: '$isEmulator',
+      kCommandRunTargetName: deviceType,
+      kCommandRunProjectModule: '${FlutterProject.current().isModule}',
+      kCommandRunProjectHostLanguage: hostLanguage.join(','),
+    };
   }
 
   @override

packages/flutter_tools/lib/src/project.dart

@@ -397,6 +397,7 @@ class AndroidProject {
   final FlutterProject parent;
 
   static final RegExp _applicationIdPattern = RegExp('^\\s*applicationId\\s+[\'\"](.*)[\'\"]\\s*\$');
+  static final RegExp _kotlinPluginPattern = RegExp('^\\s*apply plugin\:\\s+[\'\"]kotlin-android[\'\"]\\s*\$');
   static final RegExp _groupPattern = RegExp('^\\s*group\\s+[\'\"](.*)[\'\"]\\s*\$');
 
   /// The Gradle root directory of the Android host app. This is the directory
@@ -419,6 +420,12 @@ class AndroidProject {
   /// True if the parent Flutter project is a module.
   bool get isModule => parent.isModule;
 
+  /// True, if the app project is using Kotlin.
+  bool get isKotlin {
+    final File gradleFile = hostAppGradleRoot.childDirectory('app').childFile('build.gradle');
+    return _firstMatchInFile(gradleFile, _kotlinPluginPattern) != null;
+  }
+
   File get appManifestFile {
     return isUsingGradle
         ? fs.file(fs.path.join(hostAppGradleRoot.path, 'app', 'src', 'main', 'AndroidManifest.xml'))

packages/flutter_tools/lib/src/usage.dart

@@ -26,6 +26,19 @@ const String kEventReloadInvalidatedSourcesCount = 'cd11';
 const String kEventReloadTransferTimeInMs = 'cd12';
 const String kEventReloadOverallTimeInMs = 'cd13';
 
+const String kCommandRunIsEmulator = 'cd3';
+const String kCommandRunTargetName = 'cd4';
+const String kCommandRunProjectType = 'cd14';
+const String kCommandRunProjectHostLanguage = 'cd15';
+const String kCommandRunProjectModule = 'cd18';
+
+const String kCommandCreateAndroidLanguage = 'cd16';
+const String kCommandCreateIosLanguage = 'cd17';
+const String kCommandCreateProjectType = 'cd19';
+
+const String kCommandPackagesNumberPlugins = 'cd20';
+const String kCommandPackagesProjectModule = 'cd21';
+
 Usage get flutterUsage => Usage.instance;
 
 class Usage {

packages/flutter_tools/test/commands/create_test.dart

@@ -14,13 +14,16 @@ import 'package:flutter_tools/src/cache.dart';
 import 'package:flutter_tools/src/commands/create.dart';
 import 'package:flutter_tools/src/dart/sdk.dart';
 import 'package:flutter_tools/src/project.dart';
+import 'package:flutter_tools/src/usage.dart';
 import 'package:flutter_tools/src/version.dart';
+
 import 'package:mockito/mockito.dart';
 import 'package:process/process.dart';
 
 import '../src/common.dart';
 import '../src/context.dart';
 
+
 const String frameworkRevision = '12345678';
 const String frameworkChannel = 'omega';
 final Generator _kNoColorTerminalPlatform = () => FakePlatform.fromPlatform(const LocalPlatform())..stdoutSupportsAnsi = false;
@@ -927,8 +930,71 @@ void main() {
     HttpClientFactory: () =>
         () => MockHttpClient(404, result: 'not found'),
   });
+
+  group('usageValues', () {
+    testUsingContext('set template type as usage value', () async {
+      Cache.flutterRoot = '../..';
+
+      final CreateCommand command = CreateCommand();
+      final CommandRunner<void> runner = createTestCommandRunner(command);
+
+      await runner.run(<String>['create', '--no-pub', '--template=module', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'module'));
+
+      await runner.run(<String>['create', '--no-pub', '--template=app', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'app'));
+
+      await runner.run(<String>['create', '--no-pub', '--template=package', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'package'));
+
+      await runner.run(<String>['create', '--no-pub', '--template=plugin', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'plugin'));
+
+    }, timeout: allowForCreateFlutterProject);
+
+    testUsingContext('set iOS host language type as usage value', () async {
+      Cache.flutterRoot = '../..';
+
+      final CreateCommand command = CreateCommand();
+      final CommandRunner<void> runner = createTestCommandRunner(command);
+
+      await runner.run(<String>['create', '--no-pub', '--template=app', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateIosLanguage, 'objc'));
+
+      await runner.run(<String>[
+        'create',
+        '--no-pub',
+        '--template=app',
+        '--ios-language=swift',
+        projectDir.path,
+      ]);
+      expect(await command.usageValues, containsPair(kCommandCreateIosLanguage, 'swift'));
+
+    }, timeout: allowForCreateFlutterProject);
+
+    testUsingContext('set Android host language type as usage value', () async {
+      Cache.flutterRoot = '../..';
+
+      final CreateCommand command = CreateCommand();
+      final CommandRunner<void> runner = createTestCommandRunner(command);
+
+      await runner.run(<String>['create', '--no-pub', '--template=app', projectDir.path]);
+      expect(await command.usageValues, containsPair(kCommandCreateAndroidLanguage, 'java'));
+
+      await runner.run(<String>[
+        'create',
+        '--no-pub',
+        '--template=app',
+        '--android-language=kotlin',
+        projectDir.path,
+      ]);
+      expect(await command.usageValues, containsPair(kCommandCreateAndroidLanguage, 'kotlin'));
+
+    }, timeout: allowForCreateFlutterProject);
+  });
 }
 
+
 Future<void> _createProject(
   Directory dir,
   List<String> createArgs,

packages/flutter_tools/test/commands/packages_test.dart

@@ -10,6 +10,7 @@ import 'package:flutter_tools/src/base/io.dart';
 import 'package:flutter_tools/src/base/utils.dart';
 import 'package:flutter_tools/src/cache.dart';
 import 'package:flutter_tools/src/commands/packages.dart';
+import 'package:flutter_tools/src/usage.dart';
 import 'package:process/process.dart';
 
 import '../src/common.dart';
@@ -57,7 +58,7 @@ void main() {
       return projectPath;
     }
 
-    Future<void> runCommandIn(String projectPath, String verb, { List<String> args }) async {
+    Future<PackagesCommand> runCommandIn(String projectPath, String verb, { List<String> args }) async {
       final PackagesCommand command = PackagesCommand();
       final CommandRunner<void> runner = createTestCommandRunner(command);
 
@@ -67,6 +68,7 @@ void main() {
       commandArgs.add(projectPath);
 
       await runner.run(commandArgs);
+      return command;
     }
 
     void expectExists(String projectPath, String relPath) {
@@ -217,6 +219,39 @@ void main() {
       expectZeroPluginsInjected(projectPath);
     }, timeout: allowForCreateFlutterProject);
 
+    testUsingContext('set the number of plugins as usage value', () async {
+      final String projectPath = await createProject(tempDir,
+        arguments: <String>['--no-pub', '--template=module']);
+      removeGeneratedFiles(projectPath);
+
+      final PackagesCommand command = await runCommandIn(projectPath, 'get');
+      final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+      expect(await getCommand.usageValues, containsPair(kCommandPackagesNumberPlugins, '0'));
+    }, timeout: allowForCreateFlutterProject);
+
+    testUsingContext('indicate that the project is not a module in usage value', () async {
+      final String projectPath = await createProject(tempDir,
+        arguments: <String>['--no-pub']);
+      removeGeneratedFiles(projectPath);
+
+      final PackagesCommand command = await runCommandIn(projectPath, 'get');
+      final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+      expect(await getCommand.usageValues, containsPair(kCommandPackagesProjectModule, 'false'));
+    }, timeout: allowForCreateFlutterProject);
+
+    testUsingContext('indicate that the project is a module in usage value', () async {
+      final String projectPath = await createProject(tempDir,
+        arguments: <String>['--no-pub', '--template=module']);
+      removeGeneratedFiles(projectPath);
+
+      final PackagesCommand command = await runCommandIn(projectPath, 'get');
+      final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+      expect(await getCommand.usageValues, containsPair(kCommandPackagesProjectModule, 'true'));
+    }, timeout: allowForCreateFlutterProject);
+
     testUsingContext('upgrade fetches packages', () async {
       final String projectPath = await createProject(tempDir,
         arguments: <String>['--no-pub', '--template=module']);

packages/flutter_tools/test/project_test.dart

@@ -227,6 +227,41 @@ void main() {
       });
     });
 
+    group('language', () {
+      MockXcodeProjectInterpreter mockXcodeProjectInterpreter;
+      MemoryFileSystem fs;
+      setUp(() {
+        fs = MemoryFileSystem();
+        mockXcodeProjectInterpreter = MockXcodeProjectInterpreter();
+      });
+
+      testInMemory('default host app language', () async {
+        final FlutterProject project = await someProject();
+        expect(project.ios.isSwift, isFalse);
+        expect(project.android.isKotlin, isFalse);
+      });
+
+      testUsingContext('swift and kotlin host app language', () async {
+        final FlutterProject project = await someProject();
+
+        when(mockXcodeProjectInterpreter.getBuildSettings(any, any)).thenReturn(<String, String>{
+          'SWIFT_VERSION': '3.0',
+        });
+        addAndroidGradleFile(project.directory,
+          gradleFileContent: () {
+      return '''
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+''';
+        });
+        expect(project.ios.isSwift, isTrue);
+        expect(project.android.isKotlin, isTrue);
+      }, overrides: <Type, Generator>{
+          FileSystem: () => fs,
+          XcodeProjectInterpreter: () => mockXcodeProjectInterpreter,
+      });
+    });
+
     group('product bundle identifier', () {
       MemoryFileSystem fs;
       MockIOSWorkflow mockIOSWorkflow;
@@ -251,7 +286,9 @@ void main() {
       });
       testWithMocks('from pbxproj file, if no plist', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject');
+        });
         expect(project.ios.productBundleIdentifier, 'io.flutter.someProject');
       });
       testWithMocks('from plist, if no variables', () async {
@@ -261,7 +298,9 @@ void main() {
       });
       testWithMocks('from pbxproj and plist, if default variable', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject');
+        });
         when(mockIOSWorkflow.getPlistValueFromFile(any, any)).thenReturn('\$(PRODUCT_BUNDLE_IDENTIFIER)');
         expect(project.ios.productBundleIdentifier, 'io.flutter.someProject');
       });
@@ -276,17 +315,23 @@ void main() {
       });
       testWithMocks('empty surrounded by quotes', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, '', qualifier: '"');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('', qualifier: '"');
+        });
         expect(project.ios.productBundleIdentifier, '');
       });
       testWithMocks('surrounded by double quotes', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject', qualifier: '"');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject', qualifier: '"');
+        });
         expect(project.ios.productBundleIdentifier, 'io.flutter.someProject');
       });
       testWithMocks('surrounded by single quotes', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject', qualifier: '\'');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject', qualifier: '\'');
+        });
         expect(project.ios.productBundleIdentifier, 'io.flutter.someProject');
       });
     });
@@ -303,22 +348,32 @@ void main() {
       });
       testInMemory('is populated from iOS bundle identifier', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject', qualifier: '\'');
+        });
         expect(project.organizationNames, <String>['io.flutter']);
       });
       testInMemory('is populated from Android application ID', () async {
         final FlutterProject project = await someProject();
-        addAndroidWithApplicationId(project.directory, 'io.flutter.someproject');
+        addAndroidGradleFile(project.directory,
+          gradleFileContent: () {
+            return gradleFileWithApplicationId('io.flutter.someproject');
+          });
         expect(project.organizationNames, <String>['io.flutter']);
       });
       testInMemory('is populated from iOS bundle identifier in plugin example', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.example.directory, 'io.flutter.someProject');
+        addIosProjectFile(project.example.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject', qualifier: '\'');
+        });
         expect(project.organizationNames, <String>['io.flutter']);
       });
       testInMemory('is populated from Android application ID in plugin example', () async {
         final FlutterProject project = await someProject();
-        addAndroidWithApplicationId(project.example.directory, 'io.flutter.someproject');
+        addAndroidGradleFile(project.example.directory,
+          gradleFileContent: () {
+            return gradleFileWithApplicationId('io.flutter.someproject');
+          });
         expect(project.organizationNames, <String>['io.flutter']);
       });
       testInMemory('is populated from Android group in plugin', () async {
@@ -328,14 +383,24 @@ void main() {
       });
       testInMemory('is singleton, if sources agree', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject');
-        addAndroidWithApplicationId(project.directory, 'io.flutter.someproject');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject');
+        });
+        addAndroidGradleFile(project.directory,
+          gradleFileContent: () {
+            return gradleFileWithApplicationId('io.flutter.someproject');
+          });
         expect(project.organizationNames, <String>['io.flutter']);
       });
       testInMemory('is non-singleton, if sources disagree', () async {
         final FlutterProject project = await someProject();
-        addIosWithBundleId(project.directory, 'io.flutter.someProject');
-        addAndroidWithApplicationId(project.directory, 'io.clutter.someproject');
+        addIosProjectFile(project.directory, projectFileContent: () {
+          return projectFileWithBundleId('io.flutter.someProject');
+        });
+        addAndroidGradleFile(project.directory,
+          gradleFileContent: () {
+            return gradleFileWithApplicationId('io.clutter.someproject');
+          });
         expect(
           project.organizationNames,
           <String>['io.flutter', 'io.clutter'],
@@ -475,22 +540,22 @@ void expectNotExists(FileSystemEntity entity) {
   expect(entity.existsSync(), isFalse);
 }
 
-void addIosWithBundleId(Directory directory, String id, {String qualifier}) {
+void addIosProjectFile(Directory directory, {String projectFileContent()}) {
   directory
       .childDirectory('ios')
       .childDirectory('Runner.xcodeproj')
       .childFile('project.pbxproj')
         ..createSync(recursive: true)
-    ..writeAsStringSync(projectFileWithBundleId(id, qualifier: qualifier));
+    ..writeAsStringSync(projectFileContent());
 }
 
-void addAndroidWithApplicationId(Directory directory, String id) {
+void addAndroidGradleFile(Directory directory, { String gradleFileContent() }) {
   directory
       .childDirectory('android')
       .childDirectory('app')
       .childFile('build.gradle')
         ..createSync(recursive: true)
-        ..writeAsStringSync(gradleFileWithApplicationId(id));
+        ..writeAsStringSync(gradleFileContent());
 }
 
 void addAndroidWithGroup(Directory directory, String id) {