š Project: Plugin System
š Lesson 7: Advanced OOP
ā± 30-35 min
š Advanced
šÆ Objective
Create a flexible plugin architecture using abstract classes, mixins, and extensions. Build a system where plugins can be dynamically registered and executed with shared utilities.
Requirements
- Create an abstract Plugin class with init, execute, and cleanup methods
- Use mixins for shared functionality (Logging, Timing, Validation)
- Build a PluginManager that registers and runs plugins
- Create example plugins: TextProcessor, DataExporter, ImageResizer
- Track plugin execution time and status
import 'dart:math';
// Step 1: Mixins for shared functionality
mixin Logger {
void log(String message) {
print('[${DateTime.now().toIso8601String()}] ${runtimeType}: $message');
}
void warn(String message) {
print('ā ļø [${runtimeType}] $message');
}
void error(String message) {
print('ā [${runtimeType}] $message');
}
}
mixin Timer {
final Stopwatch _stopwatch = Stopwatch();
Duration get elapsed => _stopwatch.elapsed;
bool get isRunning => _stopwatch.isRunning;
void startTimer() => _stopwatch.start();
void stopTimer() => _stopwatch.stop();
void resetTimer() => _stopwatch.reset();
String get elapsedFormatted {
final ms = _stopwatch.elapsedMilliseconds;
if (ms < 1000) return '${ms}ms';
return '${(ms / 1000).toStringAsFixed(2)}s';
}
}
mixin Validator {
bool validateInput(Map input, List requiredFields) {
for (var field in requiredFields) {
if (!input.containsKey(field) || input[field] == null) {
return false;
}
}
return true;
}
}
// Step 2: Plugin status enum
enum PluginStatus { uninitialized, ready, running, completed, failed }
// Step 3: Abstract plugin class
abstract class Plugin with Logger, Timer, Validator {
final String name;
final String version;
PluginStatus _status = PluginStatus.uninitialized;
Plugin(this.name, this.version);
PluginStatus get status => _status;
Future init();
Future> execute(Map input);
Future cleanup();
Future> run(Map input) async {
log('Starting plugin v$version');
startTimer();
_status = PluginStatus.running;
try {
final result = await execute(input);
stopTimer();
_status = PluginStatus.completed;
log('Completed in $elapsedFormatted');
return result;
} catch (e) {
stopTimer();
_status = PluginStatus.failed;
error('Failed: $e');
rethrow;
} finally {
await cleanup();
}
}
}
// Step 4: Concrete plugins
class TextProcessorPlugin extends Plugin {
TextProcessorPlugin() : super('TextProcessor', '1.0.0');
@override
Future init() async {
log('Initializing...');
await Future.delayed(Duration(milliseconds: 100));
return true;
}
@override
Future> execute(Map input) async {
if (!validateInput(input, ['text'])) {
throw ArgumentError('Missing required field: text');
}
String text = input['text'] as String;
return {
'original': text,
'uppercase': text.toUpperCase(),
'lowercase': text.toLowerCase(),
'wordCount': text.split(RegExp(r'\s+')).length,
'charCount': text.length,
'reversed': text.split('').reversed.join(),
};
}
@override
Future cleanup() async {
log('Cleanup complete');
}
}
class MathPlugin extends Plugin {
MathPlugin() : super('MathOperations', '2.0.0');
@override
Future init() async {
return true;
}
@override
Future> execute(Map input) async {
if (!validateInput(input, ['numbers'])) {
throw ArgumentError('Missing required field: numbers');
}
List numbers = (input['numbers'] as List).cast();
return {
'sum': numbers.fold(0, (a, b) => a + b),
'average': numbers.fold(0.0, (a, b) => a + b.toDouble()) / numbers.length,
'min': numbers.reduce(min),
'max': numbers.reduce(max),
'count': numbers.length,
};
}
@override
Future cleanup() async {}
}
class DataGeneratorPlugin extends Plugin {
DataGeneratorPlugin() : super('DataGenerator', '1.2.0');
@override
Future init() async {
log('Seeding random generator...');
return true;
}
@override
Future> execute(Map input) async {
int count = input['count'] as int? ?? 5;
final random = Random();
List> users = [];
for (int i = 0; i < count; i++) {
users.add({
'id': i + 1,
'name': 'User_${random.nextInt(1000)}',
'age': 18 + random.nextInt(50),
'score': (random.nextDouble() * 100).toStringAsFixed(2),
});
}
return {
'users': users,
'generatedAt': DateTime.now().toIso8601String(),
'totalCount': users.length,
};
}
@override
Future cleanup() async {}
}
// Step 5: Plugin manager
class PluginManager {
final Map _plugins = {};
void register(Plugin plugin) {
_plugins[plugin.name] = plugin;
print('š¦ Registered: ${plugin.name} v${plugin.version}');
}
Future initializeAll() async {
print('\nš Initializing plugins...');
for (var plugin in _plugins.values) {
await plugin.init();
}
print('ā
All plugins initialized\n');
}
Future> executePlugin(
String name,
Map input,
) async {
final plugin = _plugins[name];
if (plugin == null) {
throw ArgumentError('Plugin not found: $name');
}
return await plugin.run(input);
}
void displayStatus() {
print('\nš Plugin Status:');
for (var plugin in _plugins.values) {
String statusIcon = switch (plugin.status) {
PluginStatus.completed => 'ā
',
PluginStatus.failed => 'ā',
PluginStatus.running => 'š',
_ => 'ā³',
};
print(' $statusIcon ${plugin.name}: ${plugin.status.name}');
}
}
}
// Step 6: Extension for result formatting
extension PluginResultExtension on Map {
void prettyPrint() {
print('ā' * 40);
forEach((key, value) {
print(' $key: $value');
});
print('ā' * 40);
}
}
// Step 7: Main program
Future main() async {
print('āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā');
print('ā PLUGIN SYSTEM ā');
print('āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n');
final manager = PluginManager();
// Register plugins
manager.register(TextProcessorPlugin());
manager.register(MathPlugin());
manager.register(DataGeneratorPlugin());
// Initialize all
await manager.initializeAll();
// Execute text processor
print('š Executing Text Processor:');
final textResult = await manager.executePlugin('TextProcessor', {
'text': 'Hello Dart Programming World',
});
textResult.prettyPrint();
// Execute math operations
print('\nš¢ Executing Math Operations:');
final mathResult = await manager.executePlugin('MathOperations', {
'numbers': [10, 25, 33, 47, 52, 68],
});
mathResult.prettyPrint();
// Execute data generator
print('\nš² Executing Data Generator:');
final dataResult = await manager.executePlugin('DataGenerator', {
'count': 3,
});
dataResult.prettyPrint();
// Display final status
manager.displayStatus();
}