packages/flutter_tools/lib/src/platform_plugins.dart - mirrors/flutter - Git at Google

 // 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:yaml/yaml.dart';

 import 'base/common.dart';
 import 'base/file_system.dart';

 /// Constant for 'pluginClass' key in plugin maps.
 const String kPluginClass = 'pluginClass';

 /// Constant for 'dartPluginClass' key in plugin maps.
 const String kDartPluginClass = 'dartPluginClass';

 /// Constant for 'ffiPlugin' key in plugin maps.
 const String kFfiPlugin = 'ffiPlugin';

 // Constant for 'defaultPackage' key in plugin maps.
 const String kDefaultPackage = 'default_package';

 /// Constant for 'supportedVariants' key in plugin maps.
 const String kSupportedVariants = 'supportedVariants';

 /// Platform variants that a Windows plugin can support.
 enum PluginPlatformVariant {
   /// Win32 variant of Windows.
   win32,
 }

 /// Marker interface for all platform specific plugin config implementations.
 abstract class PluginPlatform {
   const PluginPlatform();

   Map<String, dynamic> toMap();
 }

 /// A plugin that has platform variants.
 abstract class VariantPlatformPlugin {
   /// The platform variants supported by the plugin.
   Set<PluginPlatformVariant> get supportedVariants;
 }

 abstract class NativeOrDartPlugin {
   /// Determines whether the plugin has a Dart implementation.
   bool hasDart();

   /// Determines whether the plugin has a FFI implementation.
   bool hasFfi();

   /// Determines whether the plugin has a method channel implementation.
   bool hasMethodChannel();
 }

 /// Contains parameters to template an Android plugin.
 ///
 /// The [name] of the plugin is required. Additionally, either:
 /// - [defaultPackage], or
 /// - an implementation consisting of:
 ///   - the [package] and [pluginClass] that will be the entry point to the
 ///     plugin's native code, and/or
 ///   - the [dartPluginClass] that will be the entry point for the plugin's
 ///     Dart code
 /// is required.
 class AndroidPlugin extends PluginPlatform implements NativeOrDartPlugin {
   AndroidPlugin({
     required this.name,
     required this.pluginPath,
     this.package,
     this.pluginClass,
     this.dartPluginClass,
     bool? ffiPlugin,
     this.defaultPackage,
     required FileSystem fileSystem,
   })  : _fileSystem = fileSystem,
         ffiPlugin = ffiPlugin ?? false;

   factory AndroidPlugin.fromYaml(String name, YamlMap yaml, String pluginPath, FileSystem fileSystem) {
     assert(validate(yaml));
     return AndroidPlugin(
       name: name,
       package: yaml['package'] as String?,
       pluginClass: yaml[kPluginClass] as String?,
       dartPluginClass: yaml[kDartPluginClass] as String?,
       ffiPlugin: yaml[kFfiPlugin] as bool?,
       defaultPackage: yaml[kDefaultPackage] as String?,
       pluginPath: pluginPath,
       fileSystem: fileSystem,
     );
   }

   final FileSystem _fileSystem;

   @override
   bool hasMethodChannel() => pluginClass != null;

   @override
   bool hasFfi() => ffiPlugin;

   @override
   bool hasDart() => dartPluginClass != null;

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }
     return (yaml['package'] is String && yaml[kPluginClass] is String) ||
         yaml[kDartPluginClass] is String ||
         yaml[kFfiPlugin] == true ||
         yaml[kDefaultPackage] is String;
   }

   static const String kConfigKey = 'android';

   /// The plugin name defined in pubspec.yaml.
   final String name;

   /// The plugin package name defined in pubspec.yaml.
   final String? package;

   /// The native plugin main class defined in pubspec.yaml, if any.
   final String? pluginClass;

   /// The Dart plugin main class defined in pubspec.yaml, if any.
   final String? dartPluginClass;

   /// Is FFI plugin defined in pubspec.yaml.
   final bool ffiPlugin;

   /// The default implementation package defined in pubspec.yaml, if any.
   final String? defaultPackage;

   /// The absolute path to the plugin in the pub cache.
   final String pluginPath;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       if (package != null) 'package': package,
       if (pluginClass != null) 'class': pluginClass,
       if (dartPluginClass != null) kDartPluginClass : dartPluginClass,
       if (ffiPlugin) kFfiPlugin: true,
       if (defaultPackage != null) kDefaultPackage : defaultPackage,
       // Mustache doesn't support complex types.
       'supportsEmbeddingV1': _supportedEmbeddings.contains('1'),
       'supportsEmbeddingV2': _supportedEmbeddings.contains('2'),
     };
   }

   /// Returns the version of the Android embedding.
   late final Set<String> _supportedEmbeddings = _getSupportedEmbeddings();

   Set<String> _getSupportedEmbeddings() {
     assert(pluginPath != null);
     final Set<String> supportedEmbeddings = <String>{};
     final String baseMainPath = _fileSystem.path.join(
       pluginPath,
       'android',
       'src',
       'main',
     );

     final String? package = this.package;
     // Don't attempt to validate the native code if there isn't supposed to
     // be any.
     if (package == null) {
       return supportedEmbeddings;
     }

     final List<String> mainClassCandidates = <String>[
       _fileSystem.path.join(
         baseMainPath,
         'java',
         package.replaceAll('.', _fileSystem.path.separator),
         '$pluginClass.java',
       ),
       _fileSystem.path.join(
         baseMainPath,
         'kotlin',
         package.replaceAll('.', _fileSystem.path.separator),
         '$pluginClass.kt',
       ),
     ];

     File? mainPluginClass;
     bool mainClassFound = false;
     for (final String mainClassCandidate in mainClassCandidates) {
       mainPluginClass = _fileSystem.file(mainClassCandidate);
       if (mainPluginClass.existsSync()) {
         mainClassFound = true;
         break;
       }
     }
     if (mainPluginClass == null || !mainClassFound) {
       assert(mainClassCandidates.length <= 2);
       throwToolExit(
         "The plugin `$name` doesn't have a main class defined in ${mainClassCandidates.join(' or ')}. "
         "This is likely to due to an incorrect `androidPackage: $package` or `mainClass` entry in the plugin's pubspec.yaml.\n"
         'If you are the author of this plugin, fix the `androidPackage` entry or move the main class to any of locations used above. '
         'Otherwise, please contact the author of this plugin and consider using a different plugin in the meanwhile. '
       );
     }

     final String mainClassContent = mainPluginClass.readAsStringSync();
     if (mainClassContent
         .contains('io.flutter.embedding.engine.plugins.FlutterPlugin')) {
       supportedEmbeddings.add('2');
     } else {
       supportedEmbeddings.add('1');
     }
     if (mainClassContent.contains('PluginRegistry')
         && mainClassContent.contains('registerWith')) {
       supportedEmbeddings.add('1');
     }
     return supportedEmbeddings;
   }
 }

 /// Contains the parameters to template an iOS plugin.
 ///
 /// The [name] of the plugin is required. Additionally, either:
 /// - [defaultPackage], or
 /// - an implementation consisting of:
 ///   - the [pluginClass] (with optional [classPrefix]) that will be the entry
 ///     point to the plugin's native code, and/or
 ///   - the [dartPluginClass] that will be the entry point for the plugin's
 ///     Dart code
 /// is required.
 class IOSPlugin extends PluginPlatform implements NativeOrDartPlugin {
   const IOSPlugin({
     required this.name,
     required this.classPrefix,
     this.pluginClass,
     this.dartPluginClass,
     bool? ffiPlugin,
     this.defaultPackage,
   }) : ffiPlugin = ffiPlugin ?? false;

   factory IOSPlugin.fromYaml(String name, YamlMap yaml) {
     assert(validate(yaml)); // TODO(zanderso): https://github.com/flutter/flutter/issues/67241
     return IOSPlugin(
       name: name,
       classPrefix: '',
       pluginClass: yaml[kPluginClass] as String?,
       dartPluginClass: yaml[kDartPluginClass] as String?,
       ffiPlugin: yaml[kFfiPlugin] as bool?,
       defaultPackage: yaml[kDefaultPackage] as String?,
     );
   }

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }
     return yaml[kPluginClass] is String ||
         yaml[kDartPluginClass] is String ||
         yaml[kFfiPlugin] == true ||
         yaml[kDefaultPackage] is String;
   }

   static const String kConfigKey = 'ios';

   final String name;

   /// Note, this is here only for legacy reasons. Multi-platform format
   /// always sets it to empty String.
   final String classPrefix;
   final String? pluginClass;
   final String? dartPluginClass;
   final bool ffiPlugin;
   final String? defaultPackage;

   @override
   bool hasMethodChannel() => pluginClass != null;

   @override
   bool hasFfi() => ffiPlugin;

   @override
   bool hasDart() => dartPluginClass != null;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       'prefix': classPrefix,
       if (pluginClass != null) 'class': pluginClass,
       if (dartPluginClass != null) kDartPluginClass : dartPluginClass,
       if (ffiPlugin) kFfiPlugin: true,
       if (defaultPackage != null) kDefaultPackage : defaultPackage,
     };
   }
 }

 /// Contains the parameters to template a macOS plugin.
 ///
 /// The [name] of the plugin is required. Either [dartPluginClass] or
 /// [pluginClass] or [ffiPlugin] are required.
 /// [pluginClass] will be the entry point to the plugin's native code.
 class MacOSPlugin extends PluginPlatform implements NativeOrDartPlugin {
   const MacOSPlugin({
     required this.name,
     this.pluginClass,
     this.dartPluginClass,
     bool? ffiPlugin,
     this.defaultPackage,
   }) : ffiPlugin = ffiPlugin ?? false;

   factory MacOSPlugin.fromYaml(String name, YamlMap yaml) {
     assert(validate(yaml));
     // Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
     String? pluginClass = yaml[kPluginClass] as String?;
     if (pluginClass == 'none') {
       pluginClass = null;
     }
     return MacOSPlugin(
       name: name,
       pluginClass: pluginClass,
       dartPluginClass: yaml[kDartPluginClass] as String?,
       ffiPlugin: yaml[kFfiPlugin] as bool?,
       defaultPackage: yaml[kDefaultPackage] as String?,
     );
   }

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }
     return yaml[kPluginClass] is String ||
         yaml[kDartPluginClass] is String ||
         yaml[kFfiPlugin] == true ||
         yaml[kDefaultPackage] is String;
   }

   static const String kConfigKey = 'macos';

   final String name;
   final String? pluginClass;
   final String? dartPluginClass;
   final bool ffiPlugin;
   final String? defaultPackage;

   @override
   bool hasMethodChannel() => pluginClass != null;

   @override
   bool hasFfi() => ffiPlugin;

   @override
   bool hasDart() => dartPluginClass != null;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       if (pluginClass != null) 'class': pluginClass,
       if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
       if (ffiPlugin) kFfiPlugin: true,
       if (defaultPackage != null) kDefaultPackage: defaultPackage,
     };
   }
 }

 /// Contains the parameters to template a Windows plugin.
 ///
 /// The [name] of the plugin is required. Either [dartPluginClass] or [pluginClass] are required.
 /// [pluginClass] will be the entry point to the plugin's native code.
 class WindowsPlugin extends PluginPlatform
     implements NativeOrDartPlugin, VariantPlatformPlugin {
   const WindowsPlugin({
     required this.name,
     this.pluginClass,
     this.dartPluginClass,
     bool? ffiPlugin,
     this.defaultPackage,
     this.variants = const <PluginPlatformVariant>{},
   })  : ffiPlugin = ffiPlugin ?? false,
         assert(pluginClass != null || dartPluginClass != null || defaultPackage != null);

   factory WindowsPlugin.fromYaml(String name, YamlMap yaml) {
     assert(validate(yaml));
     // Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
     String? pluginClass = yaml[kPluginClass] as String?;
     if (pluginClass == 'none') {
       pluginClass = null;
     }
     final Set<PluginPlatformVariant> variants = <PluginPlatformVariant>{};
     final YamlList? variantList = yaml[kSupportedVariants] as YamlList?;
     if (variantList == null) {
       // If no variant list is provided assume Win32 for backward compatibility.
       variants.add(PluginPlatformVariant.win32);
     } else {
       const Map<String, PluginPlatformVariant> variantByName = <String, PluginPlatformVariant>{
         'win32': PluginPlatformVariant.win32,
       };
       for (final String variantName in variantList.cast<String>()) {
         final PluginPlatformVariant? variant = variantByName[variantName];
         if (variant != null) {
           variants.add(variant);
         }
         // Ignore unrecognized variants to make adding new variants in the
         // future non-breaking.
       }
     }
     return WindowsPlugin(
       name: name,
       pluginClass: pluginClass,
       dartPluginClass: yaml[kDartPluginClass] as String?,
       ffiPlugin: yaml[kFfiPlugin] as bool?,
       defaultPackage: yaml[kDefaultPackage] as String?,
       variants: variants,
     );
   }

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }

     return yaml[kPluginClass] is String ||
         yaml[kDartPluginClass] is String ||
         yaml[kFfiPlugin] == true ||
         yaml[kDefaultPackage] is String;
   }

   static const String kConfigKey = 'windows';

   final String name;
   final String? pluginClass;
   final String? dartPluginClass;
   final bool ffiPlugin;
   final String? defaultPackage;
   final Set<PluginPlatformVariant> variants;

   @override
   Set<PluginPlatformVariant> get supportedVariants => variants;

   @override
   bool hasMethodChannel() => pluginClass != null;

   @override
   bool hasFfi() => ffiPlugin;

   @override
   bool hasDart() => dartPluginClass != null;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       if (pluginClass != null) 'class': pluginClass,
       if (pluginClass != null) 'filename': _filenameForCppClass(pluginClass!),
       if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
       if (ffiPlugin) kFfiPlugin: true,
       if (defaultPackage != null) kDefaultPackage: defaultPackage,
     };
   }
 }

 /// Contains the parameters to template a Linux plugin.
 ///
 /// The [name] of the plugin is required. Either [dartPluginClass] or [pluginClass] are required.
 /// [pluginClass] will be the entry point to the plugin's native code.
 class LinuxPlugin extends PluginPlatform implements NativeOrDartPlugin {
   const LinuxPlugin({
     required this.name,
     this.pluginClass,
     this.dartPluginClass,
     bool? ffiPlugin,
     this.defaultPackage,
   })  : ffiPlugin = ffiPlugin ?? false,
         assert(pluginClass != null || dartPluginClass != null || (ffiPlugin ?? false) || defaultPackage != null);

   factory LinuxPlugin.fromYaml(String name, YamlMap yaml) {
     assert(validate(yaml));
     // Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
     String? pluginClass = yaml[kPluginClass] as String?;
     if (pluginClass == 'none') {
       pluginClass = null;
     }
     return LinuxPlugin(
       name: name,
       pluginClass: pluginClass,
       dartPluginClass: yaml[kDartPluginClass] as String?,
       ffiPlugin: yaml[kFfiPlugin] as bool?,
       defaultPackage: yaml[kDefaultPackage] as String?,
     );
   }

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }
     return yaml[kPluginClass] is String ||
         yaml[kDartPluginClass] is String ||
         yaml[kFfiPlugin] == true ||
         yaml[kDefaultPackage] is String;
   }

   static const String kConfigKey = 'linux';

   final String name;
   final String? pluginClass;
   final String? dartPluginClass;
   final bool ffiPlugin;
   final String? defaultPackage;

   @override
   bool hasMethodChannel() => pluginClass != null;

   @override
   bool hasFfi() => ffiPlugin;

   @override
   bool hasDart() => dartPluginClass != null;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       if (pluginClass != null) 'class': pluginClass,
       if (pluginClass != null) 'filename': _filenameForCppClass(pluginClass!),
       if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
       if (ffiPlugin) kFfiPlugin: true,
       if (defaultPackage != null) kDefaultPackage: defaultPackage,
     };
   }
 }

 /// Contains the parameters to template a web plugin.
 ///
 /// The required fields include: [name] of the plugin, the [pluginClass] that will
 /// be the entry point to the plugin's implementation, and the [fileName]
 /// containing the code.
 class WebPlugin extends PluginPlatform {
   const WebPlugin({
     required this.name,
     required this.pluginClass,
     required this.fileName,
   });

   factory WebPlugin.fromYaml(String name, YamlMap yaml) {
     assert(validate(yaml));
     return WebPlugin(
       name: name,
       pluginClass: yaml['pluginClass'] as String,
       fileName: yaml['fileName'] as String,
     );
   }

   static bool validate(YamlMap yaml) {
     if (yaml == null) {
       return false;
     }
     return yaml['pluginClass'] is String && yaml['fileName'] is String;
   }

   static const String kConfigKey = 'web';

   /// The name of the plugin.
   final String name;

   /// The class containing the plugin implementation details.
   ///
   /// This class should have a static `registerWith` method defined.
   final String pluginClass;

   /// The name of the file containing the class implementation above.
   final String fileName;

   @override
   Map<String, dynamic> toMap() {
     return <String, dynamic>{
       'name': name,
       'class': pluginClass,
       'file': fileName,
     };
   }
 }

 final RegExp _internalCapitalLetterRegex = RegExp(r'(?=(?!^)[A-Z])');
 String _filenameForCppClass(String className) {
   return className.splitMapJoin(
     _internalCapitalLetterRegex,
     onMatch: (_) => '_',
     onNonMatch: (String n) => n.toLowerCase());
 }
	// 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:yaml/yaml.dart';

	import 'base/common.dart';
	import 'base/file_system.dart';

	/// Constant for 'pluginClass' key in plugin maps.
	const String kPluginClass = 'pluginClass';

	/// Constant for 'dartPluginClass' key in plugin maps.
	const String kDartPluginClass = 'dartPluginClass';

	/// Constant for 'ffiPlugin' key in plugin maps.
	const String kFfiPlugin = 'ffiPlugin';

	// Constant for 'defaultPackage' key in plugin maps.
	const String kDefaultPackage = 'default_package';

	/// Constant for 'supportedVariants' key in plugin maps.
	const String kSupportedVariants = 'supportedVariants';

	/// Platform variants that a Windows plugin can support.
	enum PluginPlatformVariant {
	/// Win32 variant of Windows.
	win32,
	}

	/// Marker interface for all platform specific plugin config implementations.
	abstract class PluginPlatform {
	const PluginPlatform();

	Map<String, dynamic> toMap();
	}

	/// A plugin that has platform variants.
	abstract class VariantPlatformPlugin {
	/// The platform variants supported by the plugin.
	Set<PluginPlatformVariant> get supportedVariants;
	}

	abstract class NativeOrDartPlugin {
	/// Determines whether the plugin has a Dart implementation.
	bool hasDart();

	/// Determines whether the plugin has a FFI implementation.
	bool hasFfi();

	/// Determines whether the plugin has a method channel implementation.
	bool hasMethodChannel();
	}

	/// Contains parameters to template an Android plugin.
	///
	/// The [name] of the plugin is required. Additionally, either:
	/// - [defaultPackage], or
	/// - an implementation consisting of:
	/// - the [package] and [pluginClass] that will be the entry point to the
	/// plugin's native code, and/or
	/// - the [dartPluginClass] that will be the entry point for the plugin's
	/// Dart code
	/// is required.
	class AndroidPlugin extends PluginPlatform implements NativeOrDartPlugin {
	AndroidPlugin({
	required this.name,
	required this.pluginPath,
	this.package,
	this.pluginClass,
	this.dartPluginClass,
	bool? ffiPlugin,
	this.defaultPackage,
	required FileSystem fileSystem,
	}) : _fileSystem = fileSystem,
	ffiPlugin = ffiPlugin ?? false;

	factory AndroidPlugin.fromYaml(String name, YamlMap yaml, String pluginPath, FileSystem fileSystem) {
	assert(validate(yaml));
	return AndroidPlugin(
	name: name,
	package: yaml['package'] as String?,
	pluginClass: yaml[kPluginClass] as String?,
	dartPluginClass: yaml[kDartPluginClass] as String?,
	ffiPlugin: yaml[kFfiPlugin] as bool?,
	defaultPackage: yaml[kDefaultPackage] as String?,
	pluginPath: pluginPath,
	fileSystem: fileSystem,
	);
	}

	final FileSystem _fileSystem;

	@override
	bool hasMethodChannel() => pluginClass != null;

	@override
	bool hasFfi() => ffiPlugin;

	@override
	bool hasDart() => dartPluginClass != null;

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}
	return (yaml['package'] is String && yaml[kPluginClass] is String) \|\|
	yaml[kDartPluginClass] is String \|\|
	yaml[kFfiPlugin] == true \|\|
	yaml[kDefaultPackage] is String;
	}

	static const String kConfigKey = 'android';

	/// The plugin name defined in pubspec.yaml.
	final String name;

	/// The plugin package name defined in pubspec.yaml.
	final String? package;

	/// The native plugin main class defined in pubspec.yaml, if any.
	final String? pluginClass;

	/// The Dart plugin main class defined in pubspec.yaml, if any.
	final String? dartPluginClass;

	/// Is FFI plugin defined in pubspec.yaml.
	final bool ffiPlugin;

	/// The default implementation package defined in pubspec.yaml, if any.
	final String? defaultPackage;

	/// The absolute path to the plugin in the pub cache.
	final String pluginPath;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	if (package != null) 'package': package,
	if (pluginClass != null) 'class': pluginClass,
	if (dartPluginClass != null) kDartPluginClass : dartPluginClass,
	if (ffiPlugin) kFfiPlugin: true,
	if (defaultPackage != null) kDefaultPackage : defaultPackage,
	// Mustache doesn't support complex types.
	'supportsEmbeddingV1': _supportedEmbeddings.contains('1'),
	'supportsEmbeddingV2': _supportedEmbeddings.contains('2'),
	};
	}

	/// Returns the version of the Android embedding.
	late final Set<String> _supportedEmbeddings = _getSupportedEmbeddings();

	Set<String> _getSupportedEmbeddings() {
	assert(pluginPath != null);
	final Set<String> supportedEmbeddings = <String>{};
	final String baseMainPath = _fileSystem.path.join(
	pluginPath,
	'android',
	'src',
	'main',
	);

	final String? package = this.package;
	// Don't attempt to validate the native code if there isn't supposed to
	// be any.
	if (package == null) {
	return supportedEmbeddings;
	}

	final List<String> mainClassCandidates = <String>[
	_fileSystem.path.join(
	baseMainPath,
	'java',
	package.replaceAll('.', _fileSystem.path.separator),
	'$pluginClass.java',
	),
	_fileSystem.path.join(
	baseMainPath,
	'kotlin',
	package.replaceAll('.', _fileSystem.path.separator),
	'$pluginClass.kt',
	),
	];

	File? mainPluginClass;
	bool mainClassFound = false;
	for (final String mainClassCandidate in mainClassCandidates) {
	mainPluginClass = _fileSystem.file(mainClassCandidate);
	if (mainPluginClass.existsSync()) {
	mainClassFound = true;
	break;
	}
	}
	if (mainPluginClass == null \|\| !mainClassFound) {
	assert(mainClassCandidates.length <= 2);
	throwToolExit(
	"The plugin `$name` doesn't have a main class defined in ${mainClassCandidates.join(' or ')}. "
	"This is likely to due to an incorrect `androidPackage: $package` or `mainClass` entry in the plugin's pubspec.yaml.\n"
	'If you are the author of this plugin, fix the `androidPackage` entry or move the main class to any of locations used above. '
	'Otherwise, please contact the author of this plugin and consider using a different plugin in the meanwhile. '
	);
	}

	final String mainClassContent = mainPluginClass.readAsStringSync();
	if (mainClassContent
	.contains('io.flutter.embedding.engine.plugins.FlutterPlugin')) {
	supportedEmbeddings.add('2');
	} else {
	supportedEmbeddings.add('1');
	}
	if (mainClassContent.contains('PluginRegistry')
	&& mainClassContent.contains('registerWith')) {
	supportedEmbeddings.add('1');
	}
	return supportedEmbeddings;
	}
	}

	/// Contains the parameters to template an iOS plugin.
	///
	/// The [name] of the plugin is required. Additionally, either:
	/// - [defaultPackage], or
	/// - an implementation consisting of:
	/// - the [pluginClass] (with optional [classPrefix]) that will be the entry
	/// point to the plugin's native code, and/or
	/// - the [dartPluginClass] that will be the entry point for the plugin's
	/// Dart code
	/// is required.
	class IOSPlugin extends PluginPlatform implements NativeOrDartPlugin {
	const IOSPlugin({
	required this.name,
	required this.classPrefix,
	this.pluginClass,
	this.dartPluginClass,
	bool? ffiPlugin,
	this.defaultPackage,
	}) : ffiPlugin = ffiPlugin ?? false;

	factory IOSPlugin.fromYaml(String name, YamlMap yaml) {
	assert(validate(yaml)); // TODO(zanderso): https://github.com/flutter/flutter/issues/67241
	return IOSPlugin(
	name: name,
	classPrefix: '',
	pluginClass: yaml[kPluginClass] as String?,
	dartPluginClass: yaml[kDartPluginClass] as String?,
	ffiPlugin: yaml[kFfiPlugin] as bool?,
	defaultPackage: yaml[kDefaultPackage] as String?,
	);
	}

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}
	return yaml[kPluginClass] is String \|\|
	yaml[kDartPluginClass] is String \|\|
	yaml[kFfiPlugin] == true \|\|
	yaml[kDefaultPackage] is String;
	}

	static const String kConfigKey = 'ios';

	final String name;

	/// Note, this is here only for legacy reasons. Multi-platform format
	/// always sets it to empty String.
	final String classPrefix;
	final String? pluginClass;
	final String? dartPluginClass;
	final bool ffiPlugin;
	final String? defaultPackage;

	@override
	bool hasMethodChannel() => pluginClass != null;

	@override
	bool hasFfi() => ffiPlugin;

	@override
	bool hasDart() => dartPluginClass != null;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	'prefix': classPrefix,
	if (pluginClass != null) 'class': pluginClass,
	if (dartPluginClass != null) kDartPluginClass : dartPluginClass,
	if (ffiPlugin) kFfiPlugin: true,
	if (defaultPackage != null) kDefaultPackage : defaultPackage,
	};
	}
	}

	/// Contains the parameters to template a macOS plugin.
	///
	/// The [name] of the plugin is required. Either [dartPluginClass] or
	/// [pluginClass] or [ffiPlugin] are required.
	/// [pluginClass] will be the entry point to the plugin's native code.
	class MacOSPlugin extends PluginPlatform implements NativeOrDartPlugin {
	const MacOSPlugin({
	required this.name,
	this.pluginClass,
	this.dartPluginClass,
	bool? ffiPlugin,
	this.defaultPackage,
	}) : ffiPlugin = ffiPlugin ?? false;

	factory MacOSPlugin.fromYaml(String name, YamlMap yaml) {
	assert(validate(yaml));
	// Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
	String? pluginClass = yaml[kPluginClass] as String?;
	if (pluginClass == 'none') {
	pluginClass = null;
	}
	return MacOSPlugin(
	name: name,
	pluginClass: pluginClass,
	dartPluginClass: yaml[kDartPluginClass] as String?,
	ffiPlugin: yaml[kFfiPlugin] as bool?,
	defaultPackage: yaml[kDefaultPackage] as String?,
	);
	}

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}
	return yaml[kPluginClass] is String \|\|
	yaml[kDartPluginClass] is String \|\|
	yaml[kFfiPlugin] == true \|\|
	yaml[kDefaultPackage] is String;
	}

	static const String kConfigKey = 'macos';

	final String name;
	final String? pluginClass;
	final String? dartPluginClass;
	final bool ffiPlugin;
	final String? defaultPackage;

	@override
	bool hasMethodChannel() => pluginClass != null;

	@override
	bool hasFfi() => ffiPlugin;

	@override
	bool hasDart() => dartPluginClass != null;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	if (pluginClass != null) 'class': pluginClass,
	if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
	if (ffiPlugin) kFfiPlugin: true,
	if (defaultPackage != null) kDefaultPackage: defaultPackage,
	};
	}
	}

	/// Contains the parameters to template a Windows plugin.
	///
	/// The [name] of the plugin is required. Either [dartPluginClass] or [pluginClass] are required.
	/// [pluginClass] will be the entry point to the plugin's native code.
	class WindowsPlugin extends PluginPlatform
	implements NativeOrDartPlugin, VariantPlatformPlugin {
	const WindowsPlugin({
	required this.name,
	this.pluginClass,
	this.dartPluginClass,
	bool? ffiPlugin,
	this.defaultPackage,
	this.variants = const <PluginPlatformVariant>{},
	}) : ffiPlugin = ffiPlugin ?? false,
	assert(pluginClass != null \|\| dartPluginClass != null \|\| defaultPackage != null);

	factory WindowsPlugin.fromYaml(String name, YamlMap yaml) {
	assert(validate(yaml));
	// Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
	String? pluginClass = yaml[kPluginClass] as String?;
	if (pluginClass == 'none') {
	pluginClass = null;
	}
	final Set<PluginPlatformVariant> variants = <PluginPlatformVariant>{};
	final YamlList? variantList = yaml[kSupportedVariants] as YamlList?;
	if (variantList == null) {
	// If no variant list is provided assume Win32 for backward compatibility.
	variants.add(PluginPlatformVariant.win32);
	} else {
	const Map<String, PluginPlatformVariant> variantByName = <String, PluginPlatformVariant>{
	'win32': PluginPlatformVariant.win32,
	};
	for (final String variantName in variantList.cast<String>()) {
	final PluginPlatformVariant? variant = variantByName[variantName];
	if (variant != null) {
	variants.add(variant);
	}
	// Ignore unrecognized variants to make adding new variants in the
	// future non-breaking.
	}
	}
	return WindowsPlugin(
	name: name,
	pluginClass: pluginClass,
	dartPluginClass: yaml[kDartPluginClass] as String?,
	ffiPlugin: yaml[kFfiPlugin] as bool?,
	defaultPackage: yaml[kDefaultPackage] as String?,
	variants: variants,
	);
	}

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}

	return yaml[kPluginClass] is String \|\|
	yaml[kDartPluginClass] is String \|\|
	yaml[kFfiPlugin] == true \|\|
	yaml[kDefaultPackage] is String;
	}

	static const String kConfigKey = 'windows';

	final String name;
	final String? pluginClass;
	final String? dartPluginClass;
	final bool ffiPlugin;
	final String? defaultPackage;
	final Set<PluginPlatformVariant> variants;

	@override
	Set<PluginPlatformVariant> get supportedVariants => variants;

	@override
	bool hasMethodChannel() => pluginClass != null;

	@override
	bool hasFfi() => ffiPlugin;

	@override
	bool hasDart() => dartPluginClass != null;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	if (pluginClass != null) 'class': pluginClass,
	if (pluginClass != null) 'filename': _filenameForCppClass(pluginClass!),
	if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
	if (ffiPlugin) kFfiPlugin: true,
	if (defaultPackage != null) kDefaultPackage: defaultPackage,
	};
	}
	}

	/// Contains the parameters to template a Linux plugin.
	///
	/// The [name] of the plugin is required. Either [dartPluginClass] or [pluginClass] are required.
	/// [pluginClass] will be the entry point to the plugin's native code.
	class LinuxPlugin extends PluginPlatform implements NativeOrDartPlugin {
	const LinuxPlugin({
	required this.name,
	this.pluginClass,
	this.dartPluginClass,
	bool? ffiPlugin,
	this.defaultPackage,
	}) : ffiPlugin = ffiPlugin ?? false,
	assert(pluginClass != null \|\| dartPluginClass != null \|\| (ffiPlugin ?? false) \|\| defaultPackage != null);

	factory LinuxPlugin.fromYaml(String name, YamlMap yaml) {
	assert(validate(yaml));
	// Treat 'none' as not present. See https://github.com/flutter/flutter/issues/57497.
	String? pluginClass = yaml[kPluginClass] as String?;
	if (pluginClass == 'none') {
	pluginClass = null;
	}
	return LinuxPlugin(
	name: name,
	pluginClass: pluginClass,
	dartPluginClass: yaml[kDartPluginClass] as String?,
	ffiPlugin: yaml[kFfiPlugin] as bool?,
	defaultPackage: yaml[kDefaultPackage] as String?,
	);
	}

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}
	return yaml[kPluginClass] is String \|\|
	yaml[kDartPluginClass] is String \|\|
	yaml[kFfiPlugin] == true \|\|
	yaml[kDefaultPackage] is String;
	}

	static const String kConfigKey = 'linux';

	final String name;
	final String? pluginClass;
	final String? dartPluginClass;
	final bool ffiPlugin;
	final String? defaultPackage;

	@override
	bool hasMethodChannel() => pluginClass != null;

	@override
	bool hasFfi() => ffiPlugin;

	@override
	bool hasDart() => dartPluginClass != null;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	if (pluginClass != null) 'class': pluginClass,
	if (pluginClass != null) 'filename': _filenameForCppClass(pluginClass!),
	if (dartPluginClass != null) kDartPluginClass: dartPluginClass,
	if (ffiPlugin) kFfiPlugin: true,
	if (defaultPackage != null) kDefaultPackage: defaultPackage,
	};
	}
	}

	/// Contains the parameters to template a web plugin.
	///
	/// The required fields include: [name] of the plugin, the [pluginClass] that will
	/// be the entry point to the plugin's implementation, and the [fileName]
	/// containing the code.
	class WebPlugin extends PluginPlatform {
	const WebPlugin({
	required this.name,
	required this.pluginClass,
	required this.fileName,
	});

	factory WebPlugin.fromYaml(String name, YamlMap yaml) {
	assert(validate(yaml));
	return WebPlugin(
	name: name,
	pluginClass: yaml['pluginClass'] as String,
	fileName: yaml['fileName'] as String,
	);
	}

	static bool validate(YamlMap yaml) {
	if (yaml == null) {
	return false;
	}
	return yaml['pluginClass'] is String && yaml['fileName'] is String;
	}

	static const String kConfigKey = 'web';

	/// The name of the plugin.
	final String name;

	/// The class containing the plugin implementation details.
	///
	/// This class should have a static `registerWith` method defined.
	final String pluginClass;

	/// The name of the file containing the class implementation above.
	final String fileName;

	@override
	Map<String, dynamic> toMap() {
	return <String, dynamic>{
	'name': name,
	'class': pluginClass,
	'file': fileName,
	};
	}
	}

	final RegExp _internalCapitalLetterRegex = RegExp(r'(?=(?!^)[A-Z])');
	String _filenameForCppClass(String className) {
	return className.splitMapJoin(
	_internalCapitalLetterRegex,
	onMatch: (_) => '_',
	onNonMatch: (String n) => n.toLowerCase());
	}