Flutter平台集成与原生交互深度解析

import 'package:flutter/services.dart';
import 'dart:async';
import 'dart:typed_data';

// Platform Channel类型枚举
enum ChannelType {
  methodChannel,
  eventChannel,
  basicMessageChannel,
}

// Platform Channel管理器
class PlatformChannelManager {
  static PlatformChannelManager? _instance;
  static PlatformChannelManager get instance => _instance ??= PlatformChannelManager._();
  
  final Map<String, MethodChannel> _methodChannels = {};
  final Map<String, EventChannel> _eventChannels = {};
  final Map<String, BasicMessageChannel> _messageChannels = {};
  
  PlatformChannelManager._();
  
  // 创建Method Channel
  MethodChannel createMethodChannel(String name, [MethodCodec codec = const StandardMethodCodec()]) {
    if (_methodChannels.containsKey(name)) {
      return _methodChannels[name]!;
    }
    
    final channel = MethodChannel(name, codec);
    _methodChannels[name] = channel;
    return channel;
  }
  
  // 创建Event Channel
  EventChannel createEventChannel(String name, [MethodCodec codec = const StandardMethodCodec()]) {
    if (_eventChannels.containsKey(name)) {
      return _eventChannels[name]!;
    }
    
    final channel = EventChannel(name, codec);
    _eventChannels[name] = channel;
    return channel;
  }
  
  // 创建Basic Message Channel
  BasicMessageChannel<T> createMessageChannel<T>(String name, MessageCodec<T> codec) {
    final key = '${name}_${T.toString()}';
    if (_messageChannels.containsKey(key)) {
      return _messageChannels[key]! as BasicMessageChannel<T>;
    }
    
    final channel = BasicMessageChannel<T>(name, codec);
    _messageChannels[key] = channel;
    return channel;
  }
  
  // 获取已存在的Method Channel
  MethodChannel? getMethodChannel(String name) {
    return _methodChannels[name];
  }
  
  // 获取已存在的Event Channel
  EventChannel? getEventChannel(String name) {
    return _eventChannels[name];
  }
  
  // 清理所有Channel
  void dispose() {
    _methodChannels.clear();
    _eventChannels.clear();
    _messageChannels.clear();
  }
}

// 设备信息获取服务
class DeviceInfoService {
  static const String _channelName = 'com.example.device_info';
  late final MethodChannel _channel;
  
  DeviceInfoService() {
    _channel = PlatformChannelManager.instance.createMethodChannel(_channelName);
  }
  
  // 获取设备基本信息
  Future<Map<String, dynamic>> getDeviceInfo() async {
    try {
      final result = await _channel.invokeMethod('getDeviceInfo');
      return Map<String, dynamic>.from(result);
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to get device info: ${e.message}');
    }
  }
  
  // 获取设备唯一标识
  Future<String> getDeviceId() async {
    try {
      final result = await _channel.invokeMethod('getDeviceId');
      return result as String;
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to get device ID: ${e.message}');
    }
  }
  
  // 获取应用版本信息
  Future<AppVersionInfo> getAppVersionInfo() async {
    try {
      final result = await _channel.invokeMethod('getAppVersionInfo');
      return AppVersionInfo.fromMap(Map<String, dynamic>.from(result));
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to get app version info: ${e.message}');
    }
  }
  
  // 检查权限状态
  Future<PermissionStatus> checkPermission(String permission) async {
    try {
      final result = await _channel.invokeMethod('checkPermission', {
        'permission': permission,
      });
      return PermissionStatus.values[result as int];
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to check permission: ${e.message}');
    }
  }
  
  // 请求权限
  Future<PermissionStatus> requestPermission(String permission) async {
    try {
      final result = await _channel.invokeMethod('requestPermission', {
        'permission': permission,
      });
      return PermissionStatus.values[result as int];
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to request permission: ${e.message}');
    }
  }
  
  // 打开应用设置
  Future<bool> openAppSettings() async {
    try {
      final result = await _channel.invokeMethod('openAppSettings');
      return result as bool;
    } on PlatformException catch (e) {
      throw DeviceInfoException('Failed to open app settings: ${e.message}');
    }
  }
}

// 应用版本信息模型
class AppVersionInfo {
  final String appName;
  final String packageName;
  final String version;
  final String buildNumber;
  final String buildSignature;
  
  AppVersionInfo({
    required this.appName,
    required this.packageName,
    required this.version,
    required this.buildNumber,
    required this.buildSignature,
  });
  
  factory AppVersionInfo.fromMap(Map<String, dynamic> map) {
    return AppVersionInfo(
      appName: map['appName'] ?? '',
      packageName: map['packageName'] ?? '',
      version: map['version'] ?? '',
      buildNumber: map['buildNumber'] ?? '',
      buildSignature: map['buildSignature'] ?? '',
    );
  }
  
  Map<String, dynamic> toMap() {
    return {
      'appName': appName,
      'packageName': packageName,
      'version': version,
      'buildNumber': buildNumber,
      'buildSignature': buildSignature,
    };
  }
}

// 权限状态枚举
enum PermissionStatus {
  denied,
  granted,
  restricted,
  permanentlyDenied,
}

// 设备信息异常
class DeviceInfoException implements Exception {
  final String message;
  
  DeviceInfoException(this.message);
  
  @override
  String toString() => 'DeviceInfoException: $message';
}

// 传感器数据服务
class SensorDataService {
  static const String _accelerometerChannelName = 'com.example.sensors/accelerometer';
  static const String _gyroscopeChannelName = 'com.example.sensors/gyroscope';
  static const String _magnetometerChannelName = 'com.example.sensors/magnetometer';
  
  late final EventChannel _accelerometerChannel;
  late final EventChannel _gyroscopeChannel;
  late final EventChannel _magnetometerChannel;
  
  StreamSubscription<dynamic>? _accelerometerSubscription;
  StreamSubscription<dynamic>? _gyroscopeSubscription;
  StreamSubscription<dynamic>? _magnetometerSubscription;
  
  final StreamController<AccelerometerData> _accelerometerController = StreamController<AccelerometerData>.broadcast();
  final StreamController<GyroscopeData> _gyroscopeController = StreamController<GyroscopeData>.broadcast();
  final StreamController<MagnetometerData> _magnetometerController = StreamController<MagnetometerData>.broadcast();
  
  SensorDataService() {
    _accelerometerChannel = PlatformChannelManager.instance.createEventChannel(_accelerometerChannelName);
    _gyroscopeChannel = PlatformChannelManager.instance.createEventChannel(_gyroscopeChannelName);
    _magnetometerChannel = PlatformChannelManager.instance.createEventChannel(_magnetometerChannelName);
  }
  
  // 加速度计数据流
  Stream<AccelerometerData> get accelerometerStream => _accelerometerController.stream;
  
  // 陀螺仪数据流
  Stream<GyroscopeData> get gyroscopeStream => _gyroscopeController.stream;
  
  // 磁力计数据流
  Stream<MagnetometerData> get magnetometerStream => _magnetometerController.stream;
  
  // 开始监听加速度计
  void startAccelerometerListening() {
    _accelerometerSubscription?.cancel();
    _accelerometerSubscription = _accelerometerChannel.receiveBroadcastStream().listen(
      (dynamic data) {
        try {
          final map = Map<String, dynamic>.from(data);
          final accelerometerData = AccelerometerData.fromMap(map);
          _accelerometerController.add(accelerometerData);
        } catch (e) {
          print('Error parsing accelerometer data: $e');
        }
      },
      onError: (error) {
        print('Accelerometer stream error: $error');
      },
    );
  }
  
  // 开始监听陀螺仪
  void startGyroscopeListening() {
    _gyroscopeSubscription?.cancel();
    _gyroscopeSubscription = _gyroscopeChannel.receiveBroadcastStream().listen(
      (dynamic data) {
        try {
          final map = Map<String, dynamic>.from(data);
          final gyroscopeData = GyroscopeData.fromMap(map);
          _gyroscopeController.add(gyroscopeData);
        } catch (e) {
          print('Error parsing gyroscope data: $e');
        }
      },
      onError: (error) {
        print('Gyroscope stream error: $error');
      },
    );
  }
  
  // 开始监听磁力计
  void startMagnetometerListening() {
    _magnetometerSubscription?.cancel();
    _magnetometerSubscription = _magnetometerChannel.receiveBroadcastStream().listen(
      (dynamic data) {
        try {
          final map = Map<String, dynamic>.from(data);
          final magnetometerData = MagnetometerData.fromMap(map);
          _magnetometerController.add(magnetometerData);
        } catch (e) {
          print('Error parsing magnetometer data: $e');
        }
      },
      onError: (error) {
        print('Magnetometer stream error: $error');
      },
    );
  }
  
  // 停止所有传感器监听
  void stopAllListening() {
    _accelerometerSubscription?.cancel();
    _gyroscopeSubscription?.cancel();
    _magnetometerSubscription?.cancel();
  }
  
  // 清理资源
  void dispose() {
    stopAllListening();
    _accelerometerController.close();
    _gyroscopeController.close();
    _magnetometerController.close();
  }
}

// 加速度计数据模型
class AccelerometerData {
  final double x;
  final double y;
  final double z;
  final DateTime timestamp;
  
  AccelerometerData({
    required this.x,
    required this.y,
    required this.z,
    required this.timestamp,
  });
  
  factory AccelerometerData.fromMap(Map<String, dynamic> map) {
    return AccelerometerData(
      x: (map['x'] as num).toDouble(),
      y: (map['y'] as num).toDouble(),
      z: (map['z'] as num).toDouble(),
      timestamp: DateTime.fromMillisecondsSinceEpoch(map['timestamp'] as int),
    );
  }
  
  // 计算加速度大小
  double get magnitude => math.sqrt(x * x + y * y + z * z);
  
  @override
  String toString() => 'AccelerometerData(x: $x, y: $y, z: $z, timestamp: $timestamp)';
}

// 陀螺仪数据模型
class GyroscopeData {
  final double x;
  final double y;
  final double z;
  final DateTime timestamp;
  
  GyroscopeData({
    required this.x,
    required this.y,
    required this.z,
    required this.timestamp,
  });
  
  factory GyroscopeData.fromMap(Map<String, dynamic> map) {
    return GyroscopeData(
      x: (map['x'] as num).toDouble(),
      y: (map['y'] as num).toDouble(),
      z: (map['z'] as num).toDouble(),
      timestamp: DateTime.fromMillisecondsSinceEpoch(map['timestamp'] as int),
    );
  }
  
  @override
  String toString() => 'GyroscopeData(x: $x, y: $y, z: $z, timestamp: $timestamp)';
}

// 磁力计数据模型
class MagnetometerData {
  final double x;
  final double y;
  final double z;
  final DateTime timestamp;
  
  MagnetometerData({
    required this.x,
    required this.y,
    required this.z,
    required this.timestamp,
  });
  
  factory MagnetometerData.fromMap(Map<String, dynamic> map) {
    return MagnetometerData(
      x: (map['x'] as num).toDouble(),
      y: (map['y'] as num).toDouble(),
      z: (map['z'] as num).toDouble(),
      timestamp: DateTime.fromMillisecondsSinceEpoch(map['timestamp'] as int),
    );
  }
  
  @override
  String toString() => 'MagnetometerData(x: $x, y: $y, z: $z, timestamp: $timestamp)';
}

// 插件主文件结构
// lib/
//   ├── src/
//   │   ├── models/
//   │   │   ├── device_info.dart
//   │   │   ├── app_version_info.dart
//   │   │   └── sensor_data.dart
//   │   ├── services/
//   │   │   ├── device_info_service.dart
//   │   │   ├── sensor_service.dart
//   │   │   └── permission_service.dart
//   │   ├── exceptions/
//   │   │   └── platform_exceptions.dart
//   │   └── utils/
//   │       └── platform_utils.dart
//   ├── platform_integration.dart
//   └── platform_integration_platform_interface.dart

// 平台接口定义
abstract class PlatformIntegrationPlatform {
  static PlatformIntegrationPlatform _instance = MethodChannelPlatformIntegration();
  
  static PlatformIntegrationPlatform get instance => _instance;
  
  static set instance(PlatformIntegrationPlatform instance) {
    _instance = instance;
  }
  
  // 设备信息相关方法
  Future<Map<String, dynamic>> getDeviceInfo();
  Future<String> getDeviceId();
  Future<AppVersionInfo> getAppVersionInfo();
  
  // 权限相关方法
  Future<PermissionStatus> checkPermission(String permission);
  Future<PermissionStatus> requestPermission(String permission);
  Future<bool> openAppSettings();
  
  // 传感器相关方法
  Stream<AccelerometerData> get accelerometerStream;
  Stream<GyroscopeData> get gyroscopeStream;
  Stream<MagnetometerData> get magnetometerStream;
  
  void startSensorListening(SensorType sensorType);
  void stopSensorListening(SensorType sensorType);
  void stopAllSensorListening();
}

// Method Channel实现
class MethodChannelPlatformIntegration extends PlatformIntegrationPlatform {
  final DeviceInfoService _deviceInfoService = DeviceInfoService();
  final SensorDataService _sensorDataService = SensorDataService();
  
  @override
  Future<Map<String, dynamic>> getDeviceInfo() {
    return _deviceInfoService.getDeviceInfo();
  }
  
  @override
  Future<String> getDeviceId() {
    return _deviceInfoService.getDeviceId();
  }
  
  @override
  Future<AppVersionInfo> getAppVersionInfo() {
    return _deviceInfoService.getAppVersionInfo();
  }
  
  @override
  Future<PermissionStatus> checkPermission(String permission) {
    return _deviceInfoService.checkPermission(permission);
  }
  
  @override
  Future<PermissionStatus> requestPermission(String permission) {
    return _deviceInfoService.requestPermission(permission);
  }
  
  @override
  Future<bool> openAppSettings() {
    return _deviceInfoService.openAppSettings();
  }
  
  @override
  Stream<AccelerometerData> get accelerometerStream => _sensorDataService.accelerometerStream;
  
  @override
  Stream<GyroscopeData> get gyroscopeStream => _sensorDataService.gyroscopeStream;
  
  @override
  Stream<MagnetometerData> get magnetometerStream => _sensorDataService.magnetometerStream;
  
  @override
  void startSensorListening(SensorType sensorType) {
    switch (sensorType) {
      case SensorType.accelerometer:
        _sensorDataService.startAccelerometerListening();
        break;
      case SensorType.gyroscope:
        _sensorDataService.startGyroscopeListening();
        break;
      case SensorType.magnetometer:
        _sensorDataService.startMagnetometerListening();
        break;
    }
  }
  
  @override
  void stopSensorListening(SensorType sensorType) {
    // 实现停止特定传感器监听的逻辑
  }
  
  @override
  void stopAllSensorListening() {
    _sensorDataService.stopAllListening();
  }
}

// 传感器类型枚举
enum SensorType {
  accelerometer,
  gyroscope,
  magnetometer,
}

// 主要API类
class PlatformIntegration {
  static PlatformIntegrationPlatform get _platform => PlatformIntegrationPlatform.instance;
  
  // 设备信息API
  static Future<Map<String, dynamic>> getDeviceInfo() => _platform.getDeviceInfo();
  static Future<String> getDeviceId() => _platform.getDeviceId();
  static Future<AppVersionInfo> getAppVersionInfo() => _platform.getAppVersionInfo();
  
  // 权限API
  static Future<PermissionStatus> checkPermission(String permission) => _platform.checkPermission(permission);
  static Future<PermissionStatus> requestPermission(String permission) => _platform.requestPermission(permission);
  static Future<bool> openAppSettings() => _platform.openAppSettings();
  
  // 传感器API
  static Stream<AccelerometerData> get accelerometerStream => _platform.accelerometerStream;
  static Stream<GyroscopeData> get gyroscopeStream => _platform.gyroscopeStream;
  static Stream<MagnetometerData> get magnetometerStream => _platform.magnetometerStream;
  
  static void startSensorListening(SensorType sensorType) => _platform.startSensorListening(sensorType);
  static void stopSensorListening(SensorType sensorType) => _platform.stopSensorListening(sensorType);
  static void stopAllSensorListening() => _platform.stopAllSensorListening();
}

// 平台异常处理
class PlatformExceptionHandler {
  static T handlePlatformException<T>(
    Future<T> Function() operation,
    T Function(PlatformException)? onPlatformException,
    T Function(Exception)? onException,
  ) {
    try {
      return operation();
    } on PlatformException catch (e) {
      if (onPlatformException != null) {
        return onPlatformException(e);
      }
      throw PlatformIntegrationException.fromPlatformException(e);
    } catch (e) {
      if (onException != null && e is Exception) {
        return onException(e);
      }
      throw PlatformIntegrationException('Unexpected error: $e');
    }
  }
  
  static Future<T> handleAsyncPlatformException<T>(
    Future<T> Function() operation,
    T Function(PlatformException)? onPlatformException,
    T Function(Exception)? onException,
  ) async {
    try {
      return await operation();
    } on PlatformException catch (e) {
      if (onPlatformException != null) {
        return onPlatformException(e);
      }
      throw PlatformIntegrationException.fromPlatformException(e);
    } catch (e) {
      if (onException != null && e is Exception) {
        return onException(e);
      }
      throw PlatformIntegrationException('Unexpected error: $e');
    }
  }
}

// 自定义异常类
class PlatformIntegrationException implements Exception {
  final String message;
  final String? code;
  final dynamic details;
  
  PlatformIntegrationException(this.message, {this.code, this.details});
  
  factory PlatformIntegrationException.fromPlatformException(PlatformException e) {
    return PlatformIntegrationException(
      e.message ?? 'Unknown platform error',
      code: e.code,
      details: e.details,
    );
  }
  
  @override
  String toString() {
    if (code != null) {
      return 'PlatformIntegrationException($code): $message';
    }
    return 'PlatformIntegrationException: $message';
  }
}

// Channel通信优化器
class ChannelOptimizer {
  static const int _maxBatchSize = 100;
  static const Duration _batchTimeout = Duration(milliseconds: 100);
  
  final Map<String, List<dynamic>> _batchedCalls = {};
  final Map<String, Timer> _batchTimers = {};
  final Map<String, MethodChannel> _channels = {};
  
  // 批量调用优化
  Future<List<dynamic>> batchMethodCall(
    String channelName,
    List<MethodCall> calls,
  ) async {
    final channel = _getOrCreateChannel(channelName);
    
    if (calls.length == 1) {
      // 单个调用直接执行
      return [await channel.invokeMethod(calls.first.method, calls.first.arguments)];
    }
    
    // 批量调用
    final batchData = calls.map((call) => {
      'method': call.method,
      'arguments': call.arguments,
    }).toList();
    
    final results = await channel.invokeMethod('batchCall', {'calls': batchData});
    return List<dynamic>.from(results);
  }
  
  // 延迟批量调用
  Future<dynamic> deferredMethodCall(
    String channelName,
    String method,
    dynamic arguments,
  ) {
    final completer = Completer<dynamic>();
    
    _addToBatch(channelName, {
      'method': method,
      'arguments': arguments,
      'completer': completer,
    });
    
    return completer.future;
  }
  
  void _addToBatch(String channelName, Map<String, dynamic> callData) {
    _batchedCalls.putIfAbsent(channelName, () => []);
    _batchedCalls[channelName]!.add(callData);
    
    // 检查是否需要立即执行
    if (_batchedCalls[channelName]!.length >= _maxBatchSize) {
      _executeBatch(channelName);
    } else {
      // 设置延迟执行
      _batchTimers[channelName]?.cancel();
      _batchTimers[channelName] = Timer(_batchTimeout, () {
        _executeBatch(channelName);
      });
    }
  }
  
  void _executeBatch(String channelName) {
    final batch = _batchedCalls[channelName];
    if (batch == null || batch.isEmpty) return;
    
    _batchedCalls[channelName] = [];
    _batchTimers[channelName]?.cancel();
    
    final channel = _getOrCreateChannel(channelName);
    final calls = batch.map((item) => {
      'method': item['method'],
      'arguments': item['arguments'],
    }).toList();
    
    channel.invokeMethod('batchCall', {'calls': calls}).then((results) {
      final resultList = List<dynamic>.from(results);
      for (int i = 0; i < batch.length && i < resultList.length; i++) {
        final completer = batch[i]['completer'] as Completer<dynamic>;
        completer.complete(resultList[i]);
      }
    }).catchError((error) {
      for (final item in batch) {
        final completer = item['completer'] as Completer<dynamic>;
        completer.completeError(error);
      }
    });
  }
  
  MethodChannel _getOrCreateChannel(String channelName) {
    return _channels.putIfAbsent(channelName, () => MethodChannel(channelName));
  }
  
  void dispose() {
    for (final timer in _batchTimers.values) {
      timer.cancel();
    }
    _batchTimers.clear();
    _batchedCalls.clear();
    _channels.clear();
  }
}

// Platform Channel内存管理
class ChannelMemoryManager {
  static const int _maxCacheSize = 50;
  static const Duration _cacheTimeout = Duration(minutes: 5);
  
  final Map<String, CachedResult> _cache = {};
  final List<String> _cacheKeys = [];
  Timer? _cleanupTimer;
  
  ChannelMemoryManager() {
    _startCleanupTimer();
  }
  
  // 缓存结果
  void cacheResult(String key, dynamic result) {
    if (_cache.containsKey(key)) {
      _cacheKeys.remove(key);
    } else if (_cache.length >= _maxCacheSize) {
      final oldestKey = _cacheKeys.removeAt(0);
      _cache.remove(oldestKey);
    }
    
    _cache[key] = CachedResult(result, DateTime.now());
    _cacheKeys.add(key);
  }
  
  // 获取缓存结果
  dynamic getCachedResult(String key) {
    final cached = _cache[key];
    if (cached != null && !cached.isExpired(_cacheTimeout)) {
      // 移动到最后（LRU）
      _cacheKeys.remove(key);
      _cacheKeys.add(key);
      return cached.result;
    }
    
    // 过期或不存在，移除缓存
    if (cached != null) {
      _cache.remove(key);
      _cacheKeys.remove(key);
    }
    
    return null;
  }
  
  // 清理过期缓存
  void _cleanupExpiredCache() {
    final now = DateTime.now();
    final expiredKeys = <String>[];
    
    _cache.forEach((key, cached) {
      if (cached.isExpired(_cacheTimeout)) {
        expiredKeys.add(key);
      }
    });
    
    for (final key in expiredKeys) {
      _cache.remove(key);
      _cacheKeys.remove(key);
    }
  }
  
  void _startCleanupTimer() {
    _cleanupTimer = Timer.periodic(Duration(minutes: 1), (_) {
      _cleanupExpiredCache();
    });
  }
  
  void dispose() {
    _cleanupTimer?.cancel();
    _cache.clear();
    _cacheKeys.clear();
  }
}

// 缓存结果模型
class CachedResult {
  final dynamic result;
  final DateTime timestamp;
  
  CachedResult(this.result, this.timestamp);
  
  bool isExpired(Duration timeout) {
    return DateTime.now().difference(timestamp) > timeout;
  }
}