import 'package:flutter/services.dart';

class _MyHomePageState extends State<MyHomePage> {
  static const platform = MethodChannel('samples.flutter.dev/battery');
  String _batteryLevel = 'Unknown';

  Future<void> _getBatteryLevel() async {
    try {
      final int level = await platform.invokeMethod<int>('getBatteryLevel');
      setState(() => _batteryLevel = 'Battery level: $level%');
    } on PlatformException catch (e) {
      setState(() => _batteryLevel = "Failed: '${e.message}'");
    }
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(onPressed: _getBatteryLevel, child: Text('Get Battery')),
        Text(_batteryLevel),
      ],
    );
  }
}

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

class LocationService {
  static const _channel = EventChannel('samples.flutter.dev/location');

  Stream<Location> get locationStream => _channel
      .receiveBroadcastStream()
      .map((dynamic event) => Location.fromMap(Map<String, dynamic>.from(event as Map)));
}

// 使用
StreamSubscription? _subscription;

void _startListening() {
  _subscription = LocationService().locationStream.listen(
    (loc) => print('Lat: ${loc.lat}, Lng: ${loc.lng}'),
    onError: (e) => print('Error: $e'),
  );
}

void _stopListening() {
  _subscription?.cancel();
}

import 'package:pigeon/pigeon.dart';

@HostApi()
abstract class BatteryApi {
  int getBatteryLevel();
}

@HostApi()
abstract class LocationApi {
  void startLocationUpdates();
  void stopLocationUpdates();
}

@FlutterApi()
abstract class LocationCallback {
  void onLocation(double lat, double lng);
}

// 混合开发路由管理
class HybridRouter {
  static const String _FLUTTER_ROUTE_PREFIX = 'flutter://';
  static const String _NATIVE_ROUTE_PREFIX = 'native://';

  static Future<dynamic> navigateTo(String route) {
    if (route.startsWith(_FLUTTER_ROUTE_PREFIX)) {
      return _navigateToFlutter(route);
    } else if (route.startsWith(_NATIVE_ROUTE_PREFIX)) {
      return _navigateToNative(route);
    }
    throw ArgumentError('Invalid route format');
  }

  static Future<dynamic> _navigateToFlutter(String route) {
    final flutterRoute = route.replaceFirst(_FLUTTER_ROUTE_PREFIX, '');
    return Get.toNamed(flutterRoute);
  }

  static Future<dynamic> _navigateToNative(String route) {
    final nativeRoute = route.replaceFirst(_NATIVE_ROUTE_PREFIX, '');
    return _platformChannel.invokeMethod('navigate', {'route': nativeRoute});
  }
}

// navigation_service.dart
class NavigationService {
  static const _channel = MethodChannel('com.example.hybrid/navigation');

  static Future<void> navigateToNative(String route) async {
    try {
      await _channel.invokeMethod('navigateToNative', {'route': route});
    } on PlatformException catch (e) {
      debugPrint('Failed to navigate to native: ${e.message}');
    }
  }
}

// 使用
ElevatedButton(
  onPressed: () => NavigationService.navigateToNative('profile'),
  child: Text('Go to Profile'),
)

// hybrid_navigator.dart
class HybridNavigator {
  static final _nativeStack = <String>[];
  static final _flutterStack = <String>[];

  static Future<void> push(String route) async {
    if (route.startsWith('native://')) {
      _nativeStack.add(route);
      await _pushNative(route);
    } else if (route.startsWith('flutter://')) {
      _flutterStack.add(route);
      await _pushFlutter(route);
    }
  }

  static Future<void> pop() async {
    if (_flutterStack.isNotEmpty) {
      _flutterStack.removeLast();
      Get.back();
    } else if (_nativeStack.isNotEmpty) {
      _nativeStack.removeLast();
      await _popNative();
    }
  }

  static Future<void> _pushNative(String route) async {
    final channel = MethodChannel('com.example.hybrid/navigation');
    await channel.invokeMethod('pushNative', {'route': route});
  }

  static Future<void> _popNative() async {
    final channel = MethodChannel('com.example.hybrid/navigation');
    await channel.invokeMethod('popNative');
  }
}

// Flutter端
class DeviceInfoService {
  static const _channel = MethodChannel('com.example.device/info');

  static Future<Map<String, dynamic>> getDeviceInfo() async {
    try {
      final result = await _channel.invokeMethod('getDeviceInfo');
      return Map<String, dynamic>.from(result);
    } on PlatformException catch (e) {
      debugPrint('Failed to get device info: ${e.message}');
      return {};
    }
  }
}

// Android端
MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.example.device/info")
    .setMethodCallHandler { call, result ->
        when (call.method) {
            "getDeviceInfo" -> {
                val info = HashMap<String, Any>()
                info["model"] = Build.MODEL
                info["version"] = Build.VERSION.RELEASE
                info["manufacturer"] = Build.MANUFACTURER
                result.success(info)
            }
            else -> result.notImplemented()
        }
    }

// Flutter端
class LocationService {
  static const _channel = EventChannel('com.example.location/events');
  static Stream<Position>? _locationStream;

  static Stream<Position> getLocationStream() {
    _locationStream ??= _channel
        .receiveBroadcastStream()
        .map((event) => Position.fromMap(event));
    return _locationStream!;
  }
}

// 使用
LocationService.getLocationStream().listen((position) {
  print('Current position: ${position.latitude}, ${position.longitude}');
});

// Android端
EventChannel(flutterEngine.dartExecutor.binaryMessenger, "com.example.location/events")
    .setStreamHandler(object : EventChannel.StreamHandler {
        private var locationListener: LocationListener? = null
        
        override fun onListen(arguments: Any?, events: EventSink?): Boolean {
            locationListener = object : LocationListener {
                override fun onLocationChanged(location: Location) {
                    val position = HashMap<String, Double>()
                    position["latitude"] = location.latitude
                    position["longitude"] = location.longitude
                    events?.success(position)
                }
            }
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER,
                1000L,
                1.0f,
                locationListener
            )
            return true
        }
        
        override fun onCancel(arguments: Any?) {
            locationListener?.let {
                locationManager.removeUpdates(it)
            }
            locationListener = null
        }
    })

// Flutter端
class CustomMessageService {
  static const _channel = BasicMessageChannel('com.example.custom/message', 
      StandardMessageCodec());

  static Future<void> sendCustomMessage(Map<String, dynamic> message) async {
    await _channel.send(message);
  }

  static void setMessageHandler(void Function(dynamic)? handler) {
    _channel.setMessageHandler(handler);
  }
}

// Android端
BasicMessageChannel(flutterEngine.dartExecutor.binaryMessenger, 
    "com.example.custom/message", StandardMessageCodec.INSTANCE)
    .setMessageHandler { message, reply ->
        // 处理来自Flutter的消息
        val response = processMessage(message)
        reply.reply(response)
    }

class BatchChannelService {
  static const _channel = MethodChannel('com.example.batch/operations');
  
  static Future<List<dynamic>> batchExecute(List<MethodCall> calls) async {
    final batchData = calls.map((call) => {
      'method': call.method,
      'arguments': call.arguments,
    }).toList();
    
    return await _channel.invokeMethod('batchExecute', {'calls': batchData});
  }
  
  // 使用示例
  static Future<void> example() async {
    final results = await batchExecute([
      MethodCall('getUserInfo', {'userId': 1}),
      MethodCall('getUserOrders', {'userId': 1}),
      MethodCall('getUserPreferences', {'userId': 1}),
    ]);
    
    print('Batch results: $results');
  }
}

class AsyncChannelQueue {
  static final _queue = <Future<dynamic>>[];
  static bool _isProcessing = false;

  static Future<T> enqueue<T>(Future<T> Function() operation) async {
    final completer = Completer<T>();
    _queue.add(completer.future);
    
    if (!_isProcessing) {
      _processQueue();
    }
    
    return completer.future;
  }

  static Future<void> _processQueue() async {
    _isProcessing = true;
    
    while (_queue.isNotEmpty) {
      final future = _queue.removeAt(0);
      // 执行实际操作
      await future;
    }
    
    _isProcessing = false;
  }
}

class ChannelPool {
  static final _pools = <String, MethodChannel>{};
  static const _maxPoolSize = 5;

  static MethodChannel getChannel(String name) {
    if (!_pools.containsKey(name)) {
      if (_pools.length >= _maxPoolSize) {
        _pools.remove(_pools.keys.first);
      }
      _pools[name] = MethodChannel(name);
    }
    return _pools[name]!;
  }

  static void clearPool() {
    _pools.clear();
  }
}

class OptimizedCodec extends StandardMessageCodec {
  @override
  void writeValue(ByteData buffer, dynamic value) {
    if (value is CustomData) {
      // 自定义序列化逻辑
      writeUint8(buffer, 0xFF); // 自定义类型标记
      writeSize(buffer, value.data.length);
      buffer.buffer.asUint8List().setAll(buffer.offsetInBytes, value.data);
    } else {
      super.writeValue(buffer, value);
    }
  }

  @override
  dynamic readValue(ByteData buffer) {
    final type = readUint8(buffer);
    if (type == 0xFF) {
      // 自定义反序列化逻辑
      final size = readSize(buffer);
      final data = buffer.buffer.asUint8List().sublist(buffer.offsetInBytes, size);
      return CustomData(data);
    }
    return super.readValue(buffer);
  }
}

// Flutter端 - 资源清理
class HybridResourceManager {
  static final _controllers = <String, StreamController>{};
  static final _channels = <String, MethodChannel>{};

  static Stream<T> getStream<T>(String streamName) {
    if (!_controllers.containsKey(streamName)) {
      _controllers[streamName] = StreamController<T>.broadcast();
    }
    return _controllers[streamName]!.stream.cast<T>();
  }

  static void disposeStream(String streamName) {
    _controllers[streamName]?.close();
    _controllers.remove(streamName);
  }

  static void disposeAll() {
    _controllers.values.forEach((controller) => controller.close());
    _controllers.clear();
    _channels.clear();
  }
}

// 在Widget中使用
class MyWidget extends StatefulWidget {
  @override
  _MyWidgetState createState() => _MyWidgetState();
}

class _MyWidgetState extends State<MyWidget> {
  StreamSubscription? _subscription;

  @override
  void initState() {
    super.initState();
    _subscription = HybridResourceManager
        .getStream<Location>('location')
        .listen((location) {
          // 处理位置更新
        });
  }

  @override
  void dispose() {
    _subscription?.cancel();
    super.dispose();
  }
}

class ChannelPerformanceMonitor {
  static final _metrics = <String, List<int>>{};
  static const _maxMetrics = 100;

  static Future<T> monitorChannel<T>(
    String channelName,
    Future<T> Function() operation,
  ) async {
    final stopwatch = Stopwatch()..start();
    try {
      return await operation();
    } finally {
      stopwatch.stop();
      _recordMetric(channelName, stopwatch.elapsedMilliseconds);
    }
  }

  static void _recordMetric(String channelName, int duration) {
    if (!_metrics.containsKey(channelName)) {
      _metrics[channelName] = [];
    }
    _metrics[channelName]!.add(duration);
    
    if (_metrics[channelName]!.length > _maxMetrics) {
      _metrics[channelName]!.removeAt(0);
    }
    
    if (duration > 100) {
      debugPrint('⚠️ Slow channel call: $channelName took ${duration}ms');
    }
  }

  static Map<String, dynamic> getMetrics() {
    return _metrics.map((name, durations) => MapEntry(
      name,
      {
        'avg': durations.reduce((a, b) => a + b) / durations.length,
        'max': durations.reduce((a, b) => a > b ? a : b),
        'min': durations.reduce((a, b) => a < b ? a : b),
      },
    ));
  }
}

// 使用
final deviceInfo = await ChannelPerformanceMonitor.monitorChannel(
  'device/info',
  () => DeviceInfoService.getDeviceInfo(),
);

class MemoryMonitor {
  static Timer? _monitorTimer;
  static const _monitorInterval = Duration(seconds: 30);

  static void startMonitoring() {
    _monitorTimer?.cancel();
    _monitorTimer = Timer.periodic(_monitorInterval, (_) {
      _checkMemoryUsage();
    });
  }

  static void _checkMemoryUsage() {
    final memoryUsage = ProcessInfo.currentRss;
    final memoryInMB = memoryUsage / (1024 * 1024);
    
    debugPrint('Memory usage: ${memoryInMB.toStringAsFixed(2)} MB');
    
    if (memoryInMB > 500) {
      debugPrint('⚠️ High memory usage detected!');
      _performMemoryCleanup();
    }
  }

  static void _performMemoryCleanup() {
    // 清理缓存
    ImageCache().clear();
    // 清理未使用的资源
    HybridResourceManager.disposeAll();
    // 触发GC
    // 注意：Dart的GC是自动的，这里只是建议
  }

  static void stopMonitoring() {
    _monitorTimer?.cancel();
    _monitorTimer = null;
  }
}

// Flutter端 - 资源预加载
class ResourcePreloader {
  static Future<void> preloadCriticalResources() async {
    await Future.wait([
      _preloadImages(),
      _preloadFonts(),
      _preloadNetworkData(),
    ]);
  }

  static Future<void> _preloadImages() async {
    final images = ['assets/images/splash.png', 'assets/images/logo.png'];
    for (final image in images) {
      await precacheImage(AssetImage(image), Get.context!);
    }
  }

  static Future<void> _preloadFonts() async {
    // 预加载字体
    await Future.wait([
      rootBundle.load('fonts/Roboto-Regular.ttf'),
      rootBundle.load('fonts/Roboto-Bold.ttf'),
    ]);
  }

  static Future<void> _preloadNetworkData() async {
    // 预加载网络数据
    final apiService = Get.find<ApiService>();
    await apiService.prefetchCriticalData();
  }
}

// 在main.dart中使用
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // 预加载资源
  await ResourcePreloader.preloadCriticalResources();
  
  runApp(MyApp());
}

// Flutter端 - 大文件传输
class LargeFileTransfer {
  static const _chunkSize = 1024 * 1024; // 1MB chunks
  static const _channel = BasicMessageChannel('com.example.file/transfer', 
      StandardMessageCodec());

  static Future<void> sendLargeFile(String filePath) async {
    final file = File(filePath);
    final fileSize = await file.length();
    final totalChunks = (fileSize / _chunkSize).ceil();

    // 发送文件元数据
    await _channel.send({
      'type': 'metadata',
      'fileName': filePath.split('/').last,
      'fileSize': fileSize,
      'totalChunks': totalChunks,
    });

    // 分块发送文件
    final raf = await file.open(mode: FileMode.read);
    for (var i = 0; i < totalChunks; i++) {
      final chunk = await raf.read(_chunkSize);
      await _channel.send({
        'type': 'chunk',
        'chunkIndex': i,
        'data': chunk,
      });
    }
    await raf.close();

    // 发送完成信号
    await _channel.send({'type': 'complete'});
  }
}

// Flutter端 - 实时数据同步
class RealtimeDataSync {
  static const _channel = EventChannel('com.example.realtime/data');
  static const _methodChannel = MethodChannel('com.example.realtime/control');
  
  static Stream<Map<String, dynamic>>? _dataStream;
  static bool _isConnected = false;

  static Stream<Map<String, dynamic>> getDataStream() {
    _dataStream ??= _channel
        .receiveBroadcastStream()
        .map((event) => Map<String, dynamic>.from(event));
    return _dataStream!;
  }

  static Future<void> connect() async {
    await _methodChannel.invokeMethod('connect');
    _isConnected = true;
  }

  static Future<void> disconnect() async {
    await _methodChannel.invokeMethod('disconnect');
    _isConnected = false;
  }

  static Future<void> sendData(Map<String, dynamic> data) async {
    if (!_isConnected) {
      throw StateError('Not connected to realtime service');
    }
    await _methodChannel.invokeMethod('sendData', {'data': data});
  }
}

// 使用示例
class RealtimeWidget extends StatefulWidget {
  @override
  _RealtimeWidgetState createState() => _RealtimeWidgetState();
}

class _RealtimeWidgetState extends State<RealtimeWidget> {
  StreamSubscription? _subscription;

  @override
  void initState() {
    super.initState();
    _connectAndListen();
  }

  Future<void> _connectAndListen() async {
    await RealtimeDataSync.connect();
    
    _subscription = RealtimeDataSync.getDataStream().listen((data) {
      setState(() {
        // 更新UI
      });
    });
  }

  @override
  void dispose() {
    _subscription?.cancel();
    RealtimeDataSync.disconnect();
    super.dispose();
  }
}

// Flutter端 - 加密通信
class SecureChannel {
  static const _channel = MethodChannel('com.example.secure/communication');
  static final _crypto = CryptoService();

  static Future<Map<String, dynamic>> secureCall(
    String method,
    Map<String, dynamic> params,
  ) async {
    // 加密请求数据
    final encryptedRequest = await _crypto.encrypt(jsonEncode(params));
    
    try {
      // 发送加密请求
      final encryptedResponse = await _channel.invokeMethod(
        method,
        {'encryptedData': encryptedRequest},
      );
      
      // 解密响应数据
      final decryptedResponse = await _crypto.decrypt(encryptedResponse);
      return jsonDecode(decryptedResponse);
    } catch (e) {
      debugPrint('Secure call failed: $e');
      rethrow;
    }
  }
}

// 加密服务
class CryptoService {
  final _key = 'your-secret-key-32-bytes-long';
  final _iv = '16-bytes-initial-vec';

  Future<String> encrypt(String plaintext) async {
    final key = Key.fromUtf8(_key);
    final iv = IV.fromUtf8(_iv);
    final encryptor = Encrypter(AES(key, mode: AESMode.cbc));
    
    final encrypted = encryptor.encrypt(plaintext, iv: iv);
    return encrypted.base64;
  }

  Future<String> decrypt(String ciphertext) async {
    final key = Key.fromUtf8(_key);
    final iv = IV.fromUtf8(_iv);
    final encryptor = Encrypter(AES(key, mode: AESMode.cbc));
    
    final decrypted = encryptor.decrypt64(ciphertext, iv: iv);
    return decrypted;
  }
}