Stop Losing Hours to Flutter Platform Channel Bugs - Debug with AI in 20 Minutes

// flutter_debug_logger.dart
import 'dart:convert';
import 'package:flutter/services.dart';

class PlatformChannelDebugger {
  static const String _logChannel = 'debug_logger';
  static const MethodChannel _channel = MethodChannel(_logChannel);
  
  // Capture everything going through platform channels
  static Future<T?> debugMethodCall<T>(
    String channelName,
    String methodName,
    dynamic arguments,
  ) async {
    final stopwatch = Stopwatch()..start();
    
    // Log the call with full context
    final callData = {
      'channel': channelName,
      'method': methodName,
      'arguments': _sanitizeForLogging(arguments),
      'timestamp': DateTime.now().millisecondsSinceEpoch,
      'dartType': arguments.runtimeType.toString(),
    };
    
    print('🔵 PLATFORM_CALL: ${jsonEncode(callData)}');
    
    try {
      final result = await MethodChannel(channelName)
          .invokeMethod<T>(methodName, arguments);
      
      stopwatch.stop();
      
      final resultData = {
        'channel': channelName,
        'method': methodName,
        'success': true,
        'result': _sanitizeForLogging(result),
        'duration_ms': stopwatch.elapsedMilliseconds,
        'resultType': result.runtimeType.toString(),
      };
      
      print('🟢 PLATFORM_SUCCESS: ${jsonEncode(resultData)}');
      return result;
      
    } catch (error) {
      stopwatch.stop();
      
      final errorData = {
        'channel': channelName,
        'method': methodName,
        'success': false,
        'error': error.toString(),
        'duration_ms': stopwatch.elapsedMilliseconds,
        'errorType': error.runtimeType.toString(),
      };
      
      print('🔴 PLATFORM_ERROR: ${jsonEncode(errorData)}');
      rethrow;
    }
  }
  
  // Remove sensitive data but keep structure for AI analysis
  static dynamic _sanitizeForLogging(dynamic data) {
    if (data == null) return null;
    if (data is String && data.length > 1000) {
      return '${data.substring(0, 100)}...[truncated ${data.length} chars]';
    }
    if (data is Map) {
      return data.map((k, v) => MapEntry(k.toString(), _sanitizeForLogging(v)));
    }
    if (data is List) {
      return data.take(10).map(_sanitizeForLogging).toList();
    }
    return data;
  }
}

// ios/Runner/DebugLogger.swift
import Flutter

class PlatformChannelDebugLogger {
    static func logMethodCall(
        channel: String, 
        method: String, 
        arguments: Any?,
        call: FlutterMethodCall,
        result: @escaping FlutterResult
    ) {
        let startTime = CFAbsoluteTimeGetCurrent()
        
        let callData: [String: Any] = [
            "platform": "ios",
            "channel": channel,
            "method": method,
            "arguments": sanitizeForLogging(arguments),
            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
            "thread": Thread.isMainThread ? "main" : "background"
        ]
        
        print("🔵 IOS_PLATFORM_CALL: \(toJSONString(callData))")
        
        // Wrap the result to capture success/failure
        let wrappedResult: FlutterResult = { response in
            let duration = (CFAbsoluteTimeGetCurrent() - startTime) * 1000
            
            if let error = response as? FlutterError {
                let errorData: [String: Any] = [
                    "platform": "ios",
                    "channel": channel,
                    "method": method,
                    "success": false,
                    "error_code": error.code,
                    "error_message": error.message ?? "Unknown error",
                    "error_details": error.details ?? "No details",
                    "duration_ms": duration
                ]
                print("🔴 IOS_PLATFORM_ERROR: \(toJSONString(errorData))")
            } else {
                let successData: [String: Any] = [
                    "platform": "ios",
                    "channel": channel,
                    "method": method,
                    "success": true,
                    "result": sanitizeForLogging(response),
                    "duration_ms": duration
                ]
                print("🟢 IOS_PLATFORM_SUCCESS: \(toJSONString(successData))")
            }
            
            result(response)
        }
        
        return wrappedResult
    }
    
    private static func sanitizeForLogging(_ data: Any?) -> Any? {
        // Implementation similar to Dart version
        // Truncate large strings, limit array sizes, etc.
        return data // Simplified for brevity
    }
    
    private static func toJSONString(_ data: [String: Any]) -> String {
        guard let jsonData = try? JSONSerialization.data(withJSONObject: data),
              let jsonString = String(data: jsonData, encoding: .utf8) else {
            return "{\"error\": \"Failed to serialize log data\"}"
        }
        return jsonString
    }
}

# Flutter Platform Channel Bug Analysis

I'm debugging a Flutter platform channel issue. Here's the complete context:

## Flutter Environment
- Flutter version: [Your version]
- Target platforms: [iOS/Android versions]
- Channel name: [Your channel name]
- Method causing issues: [Specific method]

## Debug Logs
[Paste your captured debug logs here - both Dart and native]

## Expected Behavior
[Describe what should happen]

## Actual Behavior  
[Describe what's actually happening]

## Code Involved
**Dart side:**
```dart
[Your Dart platform channel code]

// Common iOS bug - UI calls on background thread
@objc func handleFlutterCall(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
    // ❌ This might be called on background thread
    someUIUpdate()
    result("success")
}

// Fixed version  
@objc func handleFlutterCall(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
    DispatchQueue.main.async {
        // ✅ Ensure UI calls happen on main thread
        someUIUpdate()
        result("success")
    }
}

// Common bug - rapid successive calls
class BadCameraPlugin {
  Future<void> startCamera() async {
    await channel.invokeMethod('start');
    // ❌ No wait for native setup to complete
    await takePicture(); // This will fail
  }
}

// Fixed version
class GoodCameraPlugin {
  bool _isReady = false;
  
  Future<void> startCamera() async {
    await channel.invokeMethod('start');
    // ✅ Wait for ready signal from native
    await _waitForReady();
    _isReady = true;
  }
  
  Future<void> takePicture() async {
    if (!_isReady) throw StateError('Camera not ready');
    return await channel.invokeMethod('takePicture');
  }
}

# Capture good run
flutter run --debug > good_run.log 2>&1

# Reproduce the bug 
flutter run --debug > broken_run.log 2>&1

// Add performance tracking to your debug logger
static void analyzePerformancePattern(List<Map<String, dynamic>> logs) {
  final aiPrompt = '''
  Analyze these platform channel performance logs for patterns:
  
  ${logs.map((log) => jsonEncode(log)).join('\n')}
  
  Questions:
  1. Which methods are taking longer than expected?
  2. Are there any blocking calls that should be async?
  3. Do you see memory leaks indicated by growing response times?
  ''';
  
  print('🤖 AI_ANALYSIS_PROMPT:\n$aiPrompt');
}