Flutter插件开发与发布完整指南

// 插件架构管理器
class PluginArchitectureManager {
  static PluginArchitectureManager? _instance;
  static PluginArchitectureManager get instance => _instance ??= PluginArchitectureManager._();
  
  final Map<String, PluginInterface> _registeredPlugins = {};
  final Map<String, PluginMetadata> _pluginMetadata = {};
  
  PluginArchitectureManager._();
  
  // 注册插件
  void registerPlugin<T extends PluginInterface>(String name, T plugin, PluginMetadata metadata) {
    _registeredPlugins[name] = plugin;
    _pluginMetadata[name] = metadata;
    
    debugPrint('Plugin registered: $name (${metadata.version})');
  }
  
  // 获取插件实例
  T? getPlugin<T extends PluginInterface>(String name) {
    final plugin = _registeredPlugins[name];
    if (plugin is T) {
      return plugin;
    }
    return null;
  }
  
  // 检查插件是否可用
  Future<bool> isPluginAvailable(String name) async {
    final plugin = _registeredPlugins[name];
    if (plugin == null) return false;
    
    try {
      return await plugin.isAvailable();
    } catch (e) {
      debugPrint('Plugin availability check failed for $name: $e');
      return false;
    }
  }
  
  // 获取所有已注册的插件
  List<String> getRegisteredPlugins() {
    return _registeredPlugins.keys.toList();
  }
  
  // 获取插件元数据
  PluginMetadata? getPluginMetadata(String name) {
    return _pluginMetadata[name];
  }
  
  // 卸载插件
  Future<void> unregisterPlugin(String name) async {
    final plugin = _registeredPlugins[name];
    if (plugin != null) {
      await plugin.dispose();
      _registeredPlugins.remove(name);
      _pluginMetadata.remove(name);
      debugPrint('Plugin unregistered: $name');
    }
  }
}

// 插件接口定义
abstract class PluginInterface {
  String get name;
  String get version;
  
  Future<bool> isAvailable();
  Future<void> initialize();
  Future<void> dispose();
}

// 插件元数据
class PluginMetadata {
  final String name;
  final String version;
  final String description;
  final String author;
  final List<String> supportedPlatforms;
  final Map<String, dynamic> configuration;
  
  const PluginMetadata({
    required this.name,
    required this.version,
    required this.description,
    required this.author,
    required this.supportedPlatforms,
    this.configuration = const {},
  });
  
  Map<String, dynamic> toJson() {
    return {
      'name': name,
      'version': version,
      'description': description,
      'author': author,
      'supportedPlatforms': supportedPlatforms,
      'configuration': configuration,
    };
  }
  
  factory PluginMetadata.fromJson(Map<String, dynamic> json) {
    return PluginMetadata(
      name: json['name'] as String,
      version: json['version'] as String,
      description: json['description'] as String,
      author: json['author'] as String,
      supportedPlatforms: List<String>.from(json['supportedPlatforms'] as List),
      configuration: json['configuration'] as Map<String, dynamic>? ?? {},
    );
  }
}

// 基础插件实现
abstract class BasePlugin implements PluginInterface {
  final PluginMetadata metadata;
  bool _isInitialized = false;
  
  BasePlugin(this.metadata);
  
  @override
  String get name => metadata.name;
  
  @override
  String get version => metadata.version;
  
  bool get isInitialized => _isInitialized;
  
  @override
  Future<bool> isAvailable() async {
    // 检查平台支持
    final currentPlatform = _getCurrentPlatform();
    if (!metadata.supportedPlatforms.contains(currentPlatform)) {
      return false;
    }
    
    // 子类可以重写此方法添加更多检查
    return await checkPlatformSpecificAvailability();
  }
  
  @override
  Future<void> initialize() async {
    if (_isInitialized) return;
    
    try {
      await onInitialize();
      _isInitialized = true;
      debugPrint('Plugin initialized: $name');
    } catch (e) {
      debugPrint('Plugin initialization failed for $name: $e');
      rethrow;
    }
  }
  
  @override
  Future<void> dispose() async {
    if (!_isInitialized) return;
    
    try {
      await onDispose();
      _isInitialized = false;
      debugPrint('Plugin disposed: $name');
    } catch (e) {
      debugPrint('Plugin disposal failed for $name: $e');
    }
  }
  
  // 子类需要实现的方法
  Future<bool> checkPlatformSpecificAvailability();
  Future<void> onInitialize();
  Future<void> onDispose();
  
  // 获取当前平台
  String _getCurrentPlatform() {
    if (Platform.isAndroid) return 'android';
    if (Platform.isIOS) return 'ios';
    if (Platform.isWindows) return 'windows';
    if (Platform.isMacOS) return 'macos';
    if (Platform.isLinux) return 'linux';
    if (Platform.isFuchsia) return 'fuchsia';
    return 'web';
  }
}

// 高级Method Channel封装
class AdvancedMethodChannel {
  final MethodChannel _channel;
  final String _name;
  final Map<String, Completer<dynamic>> _pendingCalls = {};
  final StreamController<MethodCall> _incomingCalls = StreamController.broadcast();
  
  AdvancedMethodChannel(this._name) : _channel = MethodChannel(_name) {
    _channel.setMethodCallHandler(_handleMethodCall);
  }
  
  // 处理来自原生端的方法调用
  Future<dynamic> _handleMethodCall(MethodCall call) async {
    _incomingCalls.add(call);
    
    // 处理回调类型的方法调用
    if (call.method.startsWith('callback_')) {
      final callId = call.arguments['callId'] as String?;
      if (callId != null && _pendingCalls.containsKey(callId)) {
        final completer = _pendingCalls.remove(callId)!;
        
        if (call.arguments['error'] != null) {
          completer.completeError(
            PlatformException(
              code: call.arguments['error']['code'] as String,
              message: call.arguments['error']['message'] as String,
              details: call.arguments['error']['details'],
            ),
          );
        } else {
          completer.complete(call.arguments['result']);
        }
      }
      return null;
    }
    
    // 其他方法调用的处理
    return null;
  }
  
  // 调用原生方法（带超时和重试）
  Future<T?> invokeMethod<T>(
    String method, {
    dynamic arguments,
    Duration timeout = const Duration(seconds: 30),
    int maxRetries = 3,
  }) async {
    Exception? lastException;
    
    for (int attempt = 0; attempt < maxRetries; attempt++) {
      try {
        final result = await _channel.invokeMethod<T>(method, arguments)
            .timeout(timeout);
        return result;
      } on TimeoutException catch (e) {
        lastException = e;
        debugPrint('Method call timeout (attempt ${attempt + 1}/$maxRetries): $method');
        
        if (attempt < maxRetries - 1) {
          await Future.delayed(Duration(milliseconds: 500 * (attempt + 1)));
        }
      } on PlatformException catch (e) {
        lastException = e;
        debugPrint('Platform exception in method call: $method - ${e.message}');
        
        // 某些错误不需要重试
        if (e.code == 'UNAVAILABLE' || e.code == 'UNIMPLEMENTED') {
          break;
        }
        
        if (attempt < maxRetries - 1) {
          await Future.delayed(Duration(milliseconds: 500 * (attempt + 1)));
        }
      } catch (e) {
        lastException = Exception('Unexpected error: $e');
        debugPrint('Unexpected error in method call: $method - $e');
        break;
      }
    }
    
    throw lastException ?? Exception('Method call failed: $method');
  }
  
  // 异步方法调用（使用回调机制）
  Future<T> invokeAsyncMethod<T>(
    String method, {
    dynamic arguments,
    Duration timeout = const Duration(minutes: 5),
  }) async {
    final callId = _generateCallId();
    final completer = Completer<T>();
    
    _pendingCalls[callId] = completer;
    
    // 设置超时
    Timer(timeout, () {
      if (_pendingCalls.containsKey(callId)) {
        _pendingCalls.remove(callId);
        if (!completer.isCompleted) {
          completer.completeError(
            TimeoutException('Async method call timeout', timeout),
          );
        }
      }
    });
    
    try {
      await _channel.invokeMethod('${method}_async', {
        'callId': callId,
        ...?arguments as Map<String, dynamic>?,
      });
      
      return await completer.future;
    } catch (e) {
      _pendingCalls.remove(callId);
      rethrow;
    }
  }
  
  // 批量方法调用
  Future<List<T?>> invokeBatchMethods<T>(List<BatchMethodCall> calls) async {
    final results = <T?>[];
    
    for (final call in calls) {
      try {
        final result = await invokeMethod<T>(
          call.method,
          arguments: call.arguments,
          timeout: call.timeout,
          maxRetries: call.maxRetries,
        );
        results.add(result);
      } catch (e) {
        if (call.continueOnError) {
          results.add(null);
          debugPrint('Batch method call failed (continuing): ${call.method} - $e');
        } else {
          rethrow;
        }
      }
    }
    
    return results;
  }
  
  // 监听来自原生端的方法调用
  Stream<MethodCall> get incomingCalls => _incomingCalls.stream;
  
  // 生成唯一的调用ID
  String _generateCallId() {
    return '${DateTime.now().millisecondsSinceEpoch}_${Random().nextInt(10000)}';
  }
  
  // 清理资源
  void dispose() {
    _incomingCalls.close();
    
    // 取消所有待处理的调用
    for (final completer in _pendingCalls.values) {
      if (!completer.isCompleted) {
        completer.completeError(Exception('Channel disposed'));
      }
    }
    _pendingCalls.clear();
  }
}

// 批量方法调用配置
class BatchMethodCall {
  final String method;
  final dynamic arguments;
  final Duration timeout;
  final int maxRetries;
  final bool continueOnError;
  
  const BatchMethodCall({
    required this.method,
    this.arguments,
    this.timeout = const Duration(seconds: 30),
    this.maxRetries = 3,
    this.continueOnError = false,
  });
}

// 高级Event Channel封装
class AdvancedEventChannel {
  final EventChannel _channel;
  final String _name;
  StreamSubscription? _subscription;
  final StreamController<dynamic> _controller = StreamController.broadcast();
  bool _isListening = false;
  
  AdvancedEventChannel(this._name) : _channel = EventChannel(_name);
  
  // 开始监听事件
  Stream<T> listen<T>({
    void Function(dynamic error)? onError,
    bool cancelOnError = false,
  }) {
    if (!_isListening) {
      _subscription = _channel.receiveBroadcastStream().listen(
        (data) {
          _controller.add(data);
        },
        onError: (error) {
          debugPrint('Event channel error ($_name): $error');
          if (onError != null) {
            onError(error);
          } else {
            _controller.addError(error);
          }
        },
        cancelOnError: cancelOnError,
      );
      _isListening = true;
    }
    
    return _controller.stream.cast<T>();
  }
  
  // 停止监听
  Future<void> stopListening() async {
    if (_isListening) {
      await _subscription?.cancel();
      _subscription = null;
      _isListening = false;
    }
  }
  
  // 过滤事件流
  Stream<T> where<T>(bool Function(T event) test) {
    return listen<T>().where(test);
  }
  
  // 转换事件流
  Stream<R> map<T, R>(R Function(T event) mapper) {
    return listen<T>().map(mapper);
  }
  
  // 缓冲事件
  Stream<List<T>> buffer<T>(Duration duration) {
    return listen<T>()
        .bufferTime(duration)
        .where((list) => list.isNotEmpty);
  }
  
  // 去重事件
  Stream<T> distinct<T>() {
    return listen<T>().distinct();
  }
  
  // 限流事件
  Stream<T> throttle<T>(Duration duration) {
    return listen<T>().throttleTime(duration);
  }
  
  // 防抖事件
  Stream<T> debounce<T>(Duration duration) {
    return listen<T>().debounceTime(duration);
  }
  
  // 清理资源
  void dispose() {
    stopListening();
    _controller.close();
  }
}

// Stream扩展方法
extension StreamExtensions<T> on Stream<T> {
  Stream<List<T>> bufferTime(Duration duration) {
    return Stream.periodic(duration)
        .switchMap((_) => take(1).toList().asStream())
        .where((list) => list.isNotEmpty);
  }
  
  Stream<T> throttleTime(Duration duration) {
    DateTime? lastEmission;
    return where((event) {
      final now = DateTime.now();
      if (lastEmission == null || now.difference(lastEmission!) >= duration) {
        lastEmission = now;
        return true;
      }
      return false;
    });
  }
  
  Stream<T> debounceTime(Duration duration) {
    Timer? timer;
    final controller = StreamController<T>();
    
    listen(
      (event) {
        timer?.cancel();
        timer = Timer(duration, () {
          controller.add(event);
        });
      },
      onError: controller.addError,
      onDone: () {
        timer?.cancel();
        controller.close();
      },
    );
    
    return controller.stream;
  }
}

// 设备信息插件主类
class DeviceInfoPlugin extends BasePlugin {
  static const String _channelName = 'com.example.device_info';
  late final AdvancedMethodChannel _methodChannel;
  late final AdvancedEventChannel _eventChannel;
  
  DeviceInfoPlugin() : super(
    const PluginMetadata(
      name: 'device_info_plus',
      version: '1.0.0',
      description: 'A comprehensive device information plugin',
      author: 'Your Name',
      supportedPlatforms: ['android', 'ios', 'windows', 'macos', 'linux'],
    ),
  );
  
  @override
  Future<bool> checkPlatformSpecificAvailability() async {
    try {
      await _methodChannel.invokeMethod('isAvailable');
      return true;
    } catch (e) {
      return false;
    }
  }
  
  @override
  Future<void> onInitialize() async {
    _methodChannel = AdvancedMethodChannel(_channelName);
    _eventChannel = AdvancedEventChannel('${_channelName}_events');
    
    // 注册插件到架构管理器
    PluginArchitectureManager.instance.registerPlugin(
      'device_info',
      this,
      metadata,
    );
  }
  
  @override
  Future<void> onDispose() async {
    _methodChannel.dispose();
    _eventChannel.dispose();
  }
  
  // 获取基本设备信息
  Future<DeviceInfo> getDeviceInfo() async {
    final result = await _methodChannel.invokeMethod<Map<String, dynamic>>('getDeviceInfo');
    if (result == null) {
      throw Exception('Failed to get device info');
    }
    
    return DeviceInfo.fromJson(result);
  }
  
  // 获取详细硬件信息
  Future<HardwareInfo> getHardwareInfo() async {
    final result = await _methodChannel.invokeMethod<Map<String, dynamic>>('getHardwareInfo');
    if (result == null) {
      throw Exception('Failed to get hardware info');
    }
    
    return HardwareInfo.fromJson(result);
  }
  
  // 获取网络信息
  Future<NetworkInfo> getNetworkInfo() async {
    final result = await _methodChannel.invokeMethod<Map<String, dynamic>>('getNetworkInfo');
    if (result == null) {
      throw Exception('Failed to get network info');
    }
    
    return NetworkInfo.fromJson(result);
  }
  
  // 获取存储信息
  Future<StorageInfo> getStorageInfo() async {
    final result = await _methodChannel.invokeMethod<Map<String, dynamic>>('getStorageInfo');
    if (result == null) {
      throw Exception('Failed to get storage info');
    }
    
    return StorageInfo.fromJson(result);
  }
  
  // 获取电池信息
  Future<BatteryInfo> getBatteryInfo() async {
    final result = await _methodChannel.invokeMethod<Map<String, dynamic>>('getBatteryInfo');
    if (result == null) {
      throw Exception('Failed to get battery info');
    }
    
    return BatteryInfo.fromJson(result);
  }
  
  // 监听电池状态变化
  Stream<BatteryInfo> get batteryStatusStream {
    return _eventChannel.listen<Map<String, dynamic>>()
        .map((data) => BatteryInfo.fromJson(data));
  }
  
  // 监听网络状态变化
  Stream<NetworkInfo> get networkStatusStream {
    return _eventChannel.listen<Map<String, dynamic>>()
        .where((data) => data['type'] == 'network')
        .map((data) => NetworkInfo.fromJson(data['data']));
  }
  
  // 获取系统性能信息
  Future<PerformanceInfo> getPerformanceInfo() async {
    final result = await _methodChannel.invokeAsyncMethod<Map<String, dynamic>>(
      'getPerformanceInfo',
      timeout: const Duration(seconds: 10),
    );
    
    return PerformanceInfo.fromJson(result);
  }
  
  // 执行系统诊断
  Future<DiagnosticResult> runDiagnostics() async {
    final result = await _methodChannel.invokeAsyncMethod<Map<String, dynamic>>(
      'runDiagnostics',
      timeout: const Duration(minutes: 2),
    );
    
    return DiagnosticResult.fromJson(result);
  }
}

// 设备信息数据模型
class DeviceInfo {
  final String deviceId;
  final String deviceName;
  final String model;
  final String manufacturer;
  final String operatingSystem;
  final String osVersion;
  final String platform;
  final bool isPhysicalDevice;
  final Map<String, dynamic> additionalInfo;
  
  const DeviceInfo({
    required this.deviceId,
    required this.deviceName,
    required this.model,
    required this.manufacturer,
    required this.operatingSystem,
    required this.osVersion,
    required this.platform,
    required this.isPhysicalDevice,
    this.additionalInfo = const {},
  });
  
  factory DeviceInfo.fromJson(Map<String, dynamic> json) {
    return DeviceInfo(
      deviceId: json['deviceId'] as String,
      deviceName: json['deviceName'] as String,
      model: json['model'] as String,
      manufacturer: json['manufacturer'] as String,
      operatingSystem: json['operatingSystem'] as String,
      osVersion: json['osVersion'] as String,
      platform: json['platform'] as String,
      isPhysicalDevice: json['isPhysicalDevice'] as bool,
      additionalInfo: json['additionalInfo'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'deviceId': deviceId,
      'deviceName': deviceName,
      'model': model,
      'manufacturer': manufacturer,
      'operatingSystem': operatingSystem,
      'osVersion': osVersion,
      'platform': platform,
      'isPhysicalDevice': isPhysicalDevice,
      'additionalInfo': additionalInfo,
    };
  }
}

// 硬件信息数据模型
class HardwareInfo {
  final String processor;
  final int coreCount;
  final String architecture;
  final int totalMemory;
  final int availableMemory;
  final String gpuInfo;
  final List<String> sensors;
  final Map<String, dynamic> additionalSpecs;
  
  const HardwareInfo({
    required this.processor,
    required this.coreCount,
    required this.architecture,
    required this.totalMemory,
    required this.availableMemory,
    required this.gpuInfo,
    required this.sensors,
    this.additionalSpecs = const {},
  });
  
  factory HardwareInfo.fromJson(Map<String, dynamic> json) {
    return HardwareInfo(
      processor: json['processor'] as String,
      coreCount: json['coreCount'] as int,
      architecture: json['architecture'] as String,
      totalMemory: json['totalMemory'] as int,
      availableMemory: json['availableMemory'] as int,
      gpuInfo: json['gpuInfo'] as String,
      sensors: List<String>.from(json['sensors'] as List),
      additionalSpecs: json['additionalSpecs'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'processor': processor,
      'coreCount': coreCount,
      'architecture': architecture,
      'totalMemory': totalMemory,
      'availableMemory': availableMemory,
      'gpuInfo': gpuInfo,
      'sensors': sensors,
      'additionalSpecs': additionalSpecs,
    };
  }
}

// 网络信息数据模型
class NetworkInfo {
  final String connectionType;
  final bool isConnected;
  final String? wifiName;
  final String? ipAddress;
  final String? macAddress;
  final int? signalStrength;
  final double? downloadSpeed;
  final double? uploadSpeed;
  final Map<String, dynamic> additionalInfo;
  
  const NetworkInfo({
    required this.connectionType,
    required this.isConnected,
    this.wifiName,
    this.ipAddress,
    this.macAddress,
    this.signalStrength,
    this.downloadSpeed,
    this.uploadSpeed,
    this.additionalInfo = const {},
  });
  
  factory NetworkInfo.fromJson(Map<String, dynamic> json) {
    return NetworkInfo(
      connectionType: json['connectionType'] as String,
      isConnected: json['isConnected'] as bool,
      wifiName: json['wifiName'] as String?,
      ipAddress: json['ipAddress'] as String?,
      macAddress: json['macAddress'] as String?,
      signalStrength: json['signalStrength'] as int?,
      downloadSpeed: (json['downloadSpeed'] as num?)?.toDouble(),
      uploadSpeed: (json['uploadSpeed'] as num?)?.toDouble(),
      additionalInfo: json['additionalInfo'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'connectionType': connectionType,
      'isConnected': isConnected,
      'wifiName': wifiName,
      'ipAddress': ipAddress,
      'macAddress': macAddress,
      'signalStrength': signalStrength,
      'downloadSpeed': downloadSpeed,
      'uploadSpeed': uploadSpeed,
      'additionalInfo': additionalInfo,
    };
  }
}

// 存储信息数据模型
class StorageInfo {
  final int totalSpace;
  final int freeSpace;
  final int usedSpace;
  final List<StorageDevice> devices;
  final Map<String, dynamic> additionalInfo;
  
  const StorageInfo({
    required this.totalSpace,
    required this.freeSpace,
    required this.usedSpace,
    required this.devices,
    this.additionalInfo = const {},
  });
  
  double get usagePercentage => (usedSpace / totalSpace) * 100;
  
  factory StorageInfo.fromJson(Map<String, dynamic> json) {
    return StorageInfo(
      totalSpace: json['totalSpace'] as int,
      freeSpace: json['freeSpace'] as int,
      usedSpace: json['usedSpace'] as int,
      devices: (json['devices'] as List)
          .map((device) => StorageDevice.fromJson(device as Map<String, dynamic>))
          .toList(),
      additionalInfo: json['additionalInfo'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'totalSpace': totalSpace,
      'freeSpace': freeSpace,
      'usedSpace': usedSpace,
      'devices': devices.map((device) => device.toJson()).toList(),
      'additionalInfo': additionalInfo,
    };
  }
}

class StorageDevice {
  final String name;
  final String type;
  final int capacity;
  final int freeSpace;
  final bool isRemovable;
  
  const StorageDevice({
    required this.name,
    required this.type,
    required this.capacity,
    required this.freeSpace,
    required this.isRemovable,
  });
  
  factory StorageDevice.fromJson(Map<String, dynamic> json) {
    return StorageDevice(
      name: json['name'] as String,
      type: json['type'] as String,
      capacity: json['capacity'] as int,
      freeSpace: json['freeSpace'] as int,
      isRemovable: json['isRemovable'] as bool,
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'name': name,
      'type': type,
      'capacity': capacity,
      'freeSpace': freeSpace,
      'isRemovable': isRemovable,
    };
  }
}

// 电池信息数据模型
class BatteryInfo {
  final int level;
  final String status;
  final String health;
  final String technology;
  final double? temperature;
  final double? voltage;
  final bool isCharging;
  final int? timeToFull;
  final int? timeToEmpty;
  
  const BatteryInfo({
    required this.level,
    required this.status,
    required this.health,
    required this.technology,
    this.temperature,
    this.voltage,
    required this.isCharging,
    this.timeToFull,
    this.timeToEmpty,
  });
  
  factory BatteryInfo.fromJson(Map<String, dynamic> json) {
    return BatteryInfo(
      level: json['level'] as int,
      status: json['status'] as String,
      health: json['health'] as String,
      technology: json['technology'] as String,
      temperature: (json['temperature'] as num?)?.toDouble(),
      voltage: (json['voltage'] as num?)?.toDouble(),
      isCharging: json['isCharging'] as bool,
      timeToFull: json['timeToFull'] as int?,
      timeToEmpty: json['timeToEmpty'] as int?,
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'level': level,
      'status': status,
      'health': health,
      'technology': technology,
      'temperature': temperature,
      'voltage': voltage,
      'isCharging': isCharging,
      'timeToFull': timeToFull,
      'timeToEmpty': timeToEmpty,
    };
  }
}

// 性能信息数据模型
class PerformanceInfo {
  final double cpuUsage;
  final double memoryUsage;
  final double diskUsage;
  final double networkUsage;
  final int runningProcesses;
  final List<ProcessInfo> topProcesses;
  final Map<String, dynamic> systemMetrics;
  
  const PerformanceInfo({
    required this.cpuUsage,
    required this.memoryUsage,
    required this.diskUsage,
    required this.networkUsage,
    required this.runningProcesses,
    required this.topProcesses,
    this.systemMetrics = const {},
  });
  
  factory PerformanceInfo.fromJson(Map<String, dynamic> json) {
    return PerformanceInfo(
      cpuUsage: (json['cpuUsage'] as num).toDouble(),
      memoryUsage: (json['memoryUsage'] as num).toDouble(),
      diskUsage: (json['diskUsage'] as num).toDouble(),
      networkUsage: (json['networkUsage'] as num).toDouble(),
      runningProcesses: json['runningProcesses'] as int,
      topProcesses: (json['topProcesses'] as List)
          .map((process) => ProcessInfo.fromJson(process as Map<String, dynamic>))
          .toList(),
      systemMetrics: json['systemMetrics'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'cpuUsage': cpuUsage,
      'memoryUsage': memoryUsage,
      'diskUsage': diskUsage,
      'networkUsage': networkUsage,
      'runningProcesses': runningProcesses,
      'topProcesses': topProcesses.map((process) => process.toJson()).toList(),
      'systemMetrics': systemMetrics,
    };
  }
}

class ProcessInfo {
  final String name;
  final int pid;
  final double cpuUsage;
  final int memoryUsage;
  
  const ProcessInfo({
    required this.name,
    required this.pid,
    required this.cpuUsage,
    required this.memoryUsage,
  });
  
  factory ProcessInfo.fromJson(Map<String, dynamic> json) {
    return ProcessInfo(
      name: json['name'] as String,
      pid: json['pid'] as int,
      cpuUsage: (json['cpuUsage'] as num).toDouble(),
      memoryUsage: json['memoryUsage'] as int,
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'name': name,
      'pid': pid,
      'cpuUsage': cpuUsage,
      'memoryUsage': memoryUsage,
    };
  }
}

// 诊断结果数据模型
class DiagnosticResult {
  final bool overallHealth;
  final List<DiagnosticTest> tests;
  final List<String> recommendations;
  final Map<String, dynamic> detailedResults;
  
  const DiagnosticResult({
    required this.overallHealth,
    required this.tests,
    required this.recommendations,
    this.detailedResults = const {},
  });
  
  factory DiagnosticResult.fromJson(Map<String, dynamic> json) {
    return DiagnosticResult(
      overallHealth: json['overallHealth'] as bool,
      tests: (json['tests'] as List)
          .map((test) => DiagnosticTest.fromJson(test as Map<String, dynamic>))
          .toList(),
      recommendations: List<String>.from(json['recommendations'] as List),
      detailedResults: json['detailedResults'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'overallHealth': overallHealth,
      'tests': tests.map((test) => test.toJson()).toList(),
      'recommendations': recommendations,
      'detailedResults': detailedResults,
    };
  }
}

class DiagnosticTest {
  final String name;
  final bool passed;
  final String? message;
  final Map<String, dynamic> details;
  
  const DiagnosticTest({
    required this.name,
    required this.passed,
    this.message,
    this.details = const {},
  });
  
  factory DiagnosticTest.fromJson(Map<String, dynamic> json) {
    return DiagnosticTest(
      name: json['name'] as String,
      passed: json['passed'] as bool,
      message: json['message'] as String?,
      details: json['details'] as Map<String, dynamic>? ?? {},
    );
  }
  
  Map<String, dynamic> toJson() {
    return {
      'name': name,
      'passed': passed,
      'message': message,
      'details': details,
    };
  }
}

// 插件使用示例
class DeviceInfoScreen extends StatefulWidget {
  const DeviceInfoScreen({Key? key}) : super(key: key);
  
  @override
  State<DeviceInfoScreen> createState() => _DeviceInfoScreenState();
}

class _DeviceInfoScreenState extends State<DeviceInfoScreen> {
  late final DeviceInfoPlugin _plugin;
  DeviceInfo? _deviceInfo;
  HardwareInfo? _hardwareInfo;
  NetworkInfo? _networkInfo;
  StorageInfo? _storageInfo;
  BatteryInfo? _batteryInfo;
  PerformanceInfo? _performanceInfo;
  bool _isLoading = true;
  String? _error;
  
  StreamSubscription? _batterySubscription;
  StreamSubscription? _networkSubscription;
  
  @override
  void initState() {
    super.initState();
    _initializePlugin();
  }
  
  @override
  void dispose() {
    _batterySubscription?.cancel();
    _networkSubscription?.cancel();
    super.dispose();
  }
  
  Future<void> _initializePlugin() async {
    try {
      _plugin = DeviceInfoPlugin();
      await _plugin.initialize();
      
      // 监听电池状态变化
      _batterySubscription = _plugin.batteryStatusStream.listen(
        (batteryInfo) {
          if (mounted) {
            setState(() {
              _batteryInfo = batteryInfo;
            });
          }
        },
        onError: (error) {
          debugPrint('Battery status stream error: $error');
        },
      );
      
      // 监听网络状态变化
      _networkSubscription = _plugin.networkStatusStream.listen(
        (networkInfo) {
          if (mounted) {
            setState(() {
              _networkInfo = networkInfo;
            });
          }
        },
        onError: (error) {
          debugPrint('Network status stream error: $error');
        },
      );
      
      await _loadDeviceInfo();
    } catch (e) {
      setState(() {
        _error = e.toString();
        _isLoading = false;
      });
    }
  }
  
  Future<void> _loadDeviceInfo() async {
    try {
      setState(() {
        _isLoading = true;
        _error = null;
      });
      
      final results = await Future.wait([
        _plugin.getDeviceInfo(),
        _plugin.getHardwareInfo(),
        _plugin.getNetworkInfo(),
        _plugin.getStorageInfo(),
        _plugin.getBatteryInfo(),
        _plugin.getPerformanceInfo(),
      ]);
      
      setState(() {
        _deviceInfo = results[0] as DeviceInfo;
        _hardwareInfo = results[1] as HardwareInfo;
        _networkInfo = results[2] as NetworkInfo;
        _storageInfo = results[3] as StorageInfo;
        _batteryInfo = results[4] as BatteryInfo;
        _performanceInfo = results[5] as PerformanceInfo;
        _isLoading = false;
      });
    } catch (e) {
      setState(() {
        _error = e.toString();
        _isLoading = false;
      });
    }
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Device Information'),
        actions: [
          IconButton(
            icon: const Icon(Icons.refresh),
            onPressed: _loadDeviceInfo,
          ),
        ],
      ),
      body: _buildBody(),
    );
  }
  
  Widget _buildBody() {
    if (_isLoading) {
      return const Center(
        child: CircularProgressIndicator(),
      );
    }
    
    if (_error != null) {
      return Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Icon(
              Icons.error_outline,
              size: 64,
              color: Theme.of(context).colorScheme.error,
            ),
            const SizedBox(height: 16),
            Text(
              'Error loading device information',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 8),
            Text(
              _error!,
              style: Theme.of(context).textTheme.bodyMedium,
              textAlign: TextAlign.center,
            ),
            const SizedBox(height: 16),
            ElevatedButton(
              onPressed: _loadDeviceInfo,
              child: const Text('Retry'),
            ),
          ],
        ),
      );
    }
    
    return SingleChildScrollView(
      padding: const EdgeInsets.all(16),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          if (_deviceInfo != null) _buildDeviceInfoCard(),
          const SizedBox(height: 16),
          if (_hardwareInfo != null) _buildHardwareInfoCard(),
          const SizedBox(height: 16),
          if (_networkInfo != null) _buildNetworkInfoCard(),
          const SizedBox(height: 16),
          if (_storageInfo != null) _buildStorageInfoCard(),
          const SizedBox(height: 16),
          if (_batteryInfo != null) _buildBatteryInfoCard(),
          const SizedBox(height: 16),
          if (_performanceInfo != null) _buildPerformanceInfoCard(),
        ],
      ),
    );
  }
  
  Widget _buildDeviceInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              'Device Information',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 16),
            _buildInfoRow('Device Name', _deviceInfo!.deviceName),
            _buildInfoRow('Model', _deviceInfo!.model),
            _buildInfoRow('Manufacturer', _deviceInfo!.manufacturer),
            _buildInfoRow('Operating System', _deviceInfo!.operatingSystem),
            _buildInfoRow('OS Version', _deviceInfo!.osVersion),
            _buildInfoRow('Platform', _deviceInfo!.platform),
            _buildInfoRow('Physical Device', _deviceInfo!.isPhysicalDevice ? 'Yes' : 'No'),
          ],
        ),
      ),
    );
  }
  
  Widget _buildHardwareInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              'Hardware Information',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 16),
            _buildInfoRow('Processor', _hardwareInfo!.processor),
            _buildInfoRow('Core Count', _hardwareInfo!.coreCount.toString()),
            _buildInfoRow('Architecture', _hardwareInfo!.architecture),
            _buildInfoRow('Total Memory', '${(_hardwareInfo!.totalMemory / 1024 / 1024 / 1024).toStringAsFixed(1)} GB'),
            _buildInfoRow('Available Memory', '${(_hardwareInfo!.availableMemory / 1024 / 1024 / 1024).toStringAsFixed(1)} GB'),
            _buildInfoRow('GPU', _hardwareInfo!.gpuInfo),
            _buildInfoRow('Sensors', _hardwareInfo!.sensors.join(', ')),
          ],
        ),
      ),
    );
  }
  
  Widget _buildNetworkInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Row(
              children: [
                Text(
                  'Network Information',
                  style: Theme.of(context).textTheme.headlineSmall,
                ),
                const Spacer(),
                Icon(
                  _networkInfo!.isConnected ? Icons.wifi : Icons.wifi_off,
                  color: _networkInfo!.isConnected ? Colors.green : Colors.red,
                ),
              ],
            ),
            const SizedBox(height: 16),
            _buildInfoRow('Connection Type', _networkInfo!.connectionType),
            _buildInfoRow('Status', _networkInfo!.isConnected ? 'Connected' : 'Disconnected'),
            if (_networkInfo!.wifiName != null)
              _buildInfoRow('WiFi Name', _networkInfo!.wifiName!),
            if (_networkInfo!.ipAddress != null)
              _buildInfoRow('IP Address', _networkInfo!.ipAddress!),
            if (_networkInfo!.signalStrength != null)
              _buildInfoRow('Signal Strength', '${_networkInfo!.signalStrength}%'),
            if (_networkInfo!.downloadSpeed != null)
              _buildInfoRow('Download Speed', '${_networkInfo!.downloadSpeed!.toStringAsFixed(1)} Mbps'),
            if (_networkInfo!.uploadSpeed != null)
              _buildInfoRow('Upload Speed', '${_networkInfo!.uploadSpeed!.toStringAsFixed(1)} Mbps'),
          ],
        ),
      ),
    );
  }
  
  Widget _buildStorageInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              'Storage Information',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 16),
            _buildInfoRow('Total Space', '${(_storageInfo!.totalSpace / 1024 / 1024 / 1024).toStringAsFixed(1)} GB'),
            _buildInfoRow('Free Space', '${(_storageInfo!.freeSpace / 1024 / 1024 / 1024).toStringAsFixed(1)} GB'),
            _buildInfoRow('Used Space', '${(_storageInfo!.usedSpace / 1024 / 1024 / 1024).toStringAsFixed(1)} GB'),
            _buildInfoRow('Usage', '${_storageInfo!.usagePercentage.toStringAsFixed(1)}%'),
            const SizedBox(height: 8),
            LinearProgressIndicator(
              value: _storageInfo!.usagePercentage / 100,
              backgroundColor: Colors.grey[300],
              valueColor: AlwaysStoppedAnimation<Color>(
                _storageInfo!.usagePercentage > 80 ? Colors.red : Colors.blue,
              ),
            ),
          ],
        ),
      ),
    );
  }
  
  Widget _buildBatteryInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Row(
              children: [
                Text(
                  'Battery Information',
                  style: Theme.of(context).textTheme.headlineSmall,
                ),
                const Spacer(),
                Icon(
                  _batteryInfo!.isCharging ? Icons.battery_charging_full : Icons.battery_std,
                  color: _getBatteryColor(_batteryInfo!.level),
                ),
                Text(
                  '${_batteryInfo!.level}%',
                  style: Theme.of(context).textTheme.titleMedium,
                ),
              ],
            ),
            const SizedBox(height: 16),
            _buildInfoRow('Status', _batteryInfo!.status),
            _buildInfoRow('Health', _batteryInfo!.health),
            _buildInfoRow('Technology', _batteryInfo!.technology),
            _buildInfoRow('Charging', _batteryInfo!.isCharging ? 'Yes' : 'No'),
            if (_batteryInfo!.temperature != null)
              _buildInfoRow('Temperature', '${_batteryInfo!.temperature!.toStringAsFixed(1)}°C'),
            if (_batteryInfo!.voltage != null)
              _buildInfoRow('Voltage', '${_batteryInfo!.voltage!.toStringAsFixed(2)}V'),
            const SizedBox(height: 8),
            LinearProgressIndicator(
              value: _batteryInfo!.level / 100,
              backgroundColor: Colors.grey[300],
              valueColor: AlwaysStoppedAnimation<Color>(
                _getBatteryColor(_batteryInfo!.level),
              ),
            ),
          ],
        ),
      ),
    );
  }
  
  Widget _buildPerformanceInfoCard() {
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              'Performance Information',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 16),
            _buildInfoRow('CPU Usage', '${_performanceInfo!.cpuUsage.toStringAsFixed(1)}%'),
            _buildInfoRow('Memory Usage', '${_performanceInfo!.memoryUsage.toStringAsFixed(1)}%'),
            _buildInfoRow('Disk Usage', '${_performanceInfo!.diskUsage.toStringAsFixed(1)}%'),
            _buildInfoRow('Network Usage', '${_performanceInfo!.networkUsage.toStringAsFixed(1)}%'),
            _buildInfoRow('Running Processes', _performanceInfo!.runningProcesses.toString()),
          ],
        ),
      ),
    );
  }
  
  Widget _buildInfoRow(String label, String value) {
    return Padding(
      padding: const EdgeInsets.symmetric(vertical: 4),
      child: Row(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          SizedBox(
            width: 120,
            child: Text(
              label,
              style: Theme.of(context).textTheme.bodyMedium?.copyWith(
                fontWeight: FontWeight.w500,
              ),
            ),
          ),
          Expanded(
            child: Text(
              value,
              style: Theme.of(context).textTheme.bodyMedium,
            ),
          ),
        ],
      ),
    );
  }
  
  Color _getBatteryColor(int level) {
    if (level > 50) return Colors.green;
    if (level > 20) return Colors.orange;
    return Colors.red;
  }
}

// test/device_info_plugin_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/mockito.dart';
import 'package:mockito/annotations.dart';
import 'package:device_info_plugin/device_info_plugin.dart';

@GenerateMocks([AdvancedMethodChannel])
import 'device_info_plugin_test.mocks.dart';

void main() {
  group('DeviceInfoPlugin', () {
    late DeviceInfoPlugin plugin;
    late MockAdvancedMethodChannel mockChannel;
    
    setUp(() {
      mockChannel = MockAdvancedMethodChannel();
      plugin = DeviceInfoPlugin();
      // 注入mock channel
    });
    
    group('initialization', () {
      test('should initialize successfully', () async {
        when(mockChannel.invokeMethod('isAvailable'))
            .thenAnswer((_) async => true);
        
        await plugin.initialize();
        
        expect(plugin.isInitialized, isTrue);
        verify(mockChannel.invokeMethod('isAvailable')).called(1);
      });
      
      test('should handle initialization failure', () async {
        when(mockChannel.invokeMethod('isAvailable'))
            .thenThrow(Exception('Platform not supported'));
        
        expect(
          () => plugin.initialize(),
          throwsException,
        );
      });
    });
    
    group('device info', () {
      test('should return device info successfully', () async {
        final mockDeviceInfo = {
          'deviceId': 'test-device-id',
          'deviceName': 'Test Device',
          'model': 'Test Model',
          'manufacturer': 'Test Manufacturer',
          'operatingSystem': 'Test OS',
          'osVersion': '1.0.0',
          'platform': 'test',
          'isPhysicalDevice': true,
          'additionalInfo': {},
        };
        
        when(mockChannel.invokeMethod<Map<String, dynamic>>('getDeviceInfo'))
            .thenAnswer((_) async => mockDeviceInfo);
        
        final result = await plugin.getDeviceInfo();
        
        expect(result.deviceId, equals('test-device-id'));
        expect(result.deviceName, equals('Test Device'));
        expect(result.isPhysicalDevice, isTrue);
        verify(mockChannel.invokeMethod('getDeviceInfo')).called(1);
      });
      
      test('should handle device info failure', () async {
        when(mockChannel.invokeMethod<Map<String, dynamic>>('getDeviceInfo'))
            .thenAnswer((_) async => null);
        
        expect(
          () => plugin.getDeviceInfo(),
          throwsException,
        );
      });
    });
    
    group('hardware info', () {
      test('should return hardware info successfully', () async {
        final mockHardwareInfo = {
          'processor': 'Test Processor',
          'coreCount': 8,
          'architecture': 'arm64',
          'totalMemory': 8589934592, // 8GB
          'availableMemory': 4294967296, // 4GB
          'gpuInfo': 'Test GPU',
          'sensors': ['accelerometer', 'gyroscope'],
          'additionalSpecs': {},
        };
        
        when(mockChannel.invokeMethod<Map<String, dynamic>>('getHardwareInfo'))
            .thenAnswer((_) async => mockHardwareInfo);
        
        final result = await plugin.getHardwareInfo();
        
        expect(result.processor, equals('Test Processor'));
        expect(result.coreCount, equals(8));
        expect(result.architecture, equals('arm64'));
        expect(result.sensors, contains('accelerometer'));
        verify(mockChannel.invokeMethod('getHardwareInfo')).called(1);
      });
    });
    
    group('battery info stream', () {
      test('should emit battery info updates', () async {
        final mockBatteryInfo = {
          'level': 75,
          'status': 'charging',
          'health': 'good',
          'technology': 'Li-ion',
          'isCharging': true,
        };
        
        // 模拟事件流
        final controller = StreamController<Map<String, dynamic>>();
        when(mockChannel.listen<Map<String, dynamic>>())
            .thenAnswer((_) => controller.stream);
        
        final stream = plugin.batteryStatusStream;
        
        // 发送测试数据
        controller.add(mockBatteryInfo);
        
        await expectLater(
          stream.take(1),
          emits(predicate<BatteryInfo>((info) => 
            info.level == 75 && 
            info.status == 'charging' &&
            info.isCharging == true
          )),
        );
        
        await controller.close();
      });
    });
    
    tearDown(() async {
      await plugin.dispose();
    });
  });
}

// 集成测试
// integration_test/plugin_integration_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:device_info_plugin_example/main.dart' as app;

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
  
  group('DeviceInfoPlugin Integration Tests', () {
    testWidgets('should load device information successfully', (tester) async {
      app.main();
      await tester.pumpAndSettle();
      
      // 等待数据加载
      await tester.pump(const Duration(seconds: 3));
      
      // 验证设备信息卡片存在
      expect(find.text('Device Information'), findsOneWidget);
      expect(find.text('Hardware Information'), findsOneWidget);
      expect(find.text('Network Information'), findsOneWidget);
      expect(find.text('Storage Information'), findsOneWidget);
      expect(find.text('Battery Information'), findsOneWidget);
      
      // 验证刷新功能
      await tester.tap(find.byIcon(Icons.refresh));
      await tester.pumpAndSettle();
      
      // 验证数据重新加载
      expect(find.byType(CircularProgressIndicator), findsNothing);
    });
    
    testWidgets('should handle network status changes', (tester) async {
      app.main();
      await tester.pumpAndSettle();
      
      // 等待初始加载
      await tester.pump(const Duration(seconds: 2));
      
      // 查找网络状态图标
      final networkIcon = find.byIcon(Icons.wifi).or(find.byIcon(Icons.wifi_off));
      expect(networkIcon, findsOneWidget);
      
      // 模拟网络状态变化（这需要在原生端配合）
      // 实际测试中可能需要手动切换网络状态
    });
  });
}