Flutter Native Channels — Platform-Specific Code and Method Channels

import 'package:flutter/services.dart';

class BatteryService {
  static const _channel = MethodChannel('com.dodatech/battery');

  Future<int> getBatteryLevel() async {
    try {
      final result = await _channel.invokeMethod<int>('getBatteryLevel');
      return result ?? -1;
    } on PlatformException catch (e) {
      print('Battery error: ${e.message}');
      return -1;
    }
  }

  Future<bool> startCharging() async {
    try {
      final result = await _channel.invokeMethod<bool>('startCharging');
      return result ?? false;
    } on PlatformException catch (e) {
      print('Charging error: ${e.message}');
      return false;
    }
  }
}

// android/app/src/main/kotlin/com/dodatech/myapp/MainActivity.kt
import android.os.BatteryManager
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.dodatech/battery"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        
        MethodChannel(
            flutterEngine.dartExecutor.binaryMessenger,
            CHANNEL
        ).setMethodCallHandler { call, result ->
            when (call.method) {
                "getBatteryLevel" -> {
                    val batteryLevel = getBatteryLevel()
                    if (batteryLevel != -1) {
                        result.success(batteryLevel)
                    } else {
                        result.error("UNAVAILABLE", "Battery level not available", null)
                    }
                }
                "startCharging" -> {
                    // Simulate starting a charging process
                    result.success(true)
                }
                else -> result.notImplemented()
            }
        }
    }

    private fun getBatteryLevel(): Int {
        val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
        return batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
    }
}

// ios/Runner/AppDelegate.swift
import UIKit
import Flutter

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        let controller = window?.rootViewController as! FlutterViewController
        let batteryChannel = FlutterMethodChannel(
            name: "com.dodatech/battery",
            binaryMessenger: controller.binaryMessenger
        )

        batteryChannel.setMethodCallHandler { [weak self] (call, result) in
            switch call.method {
            case "getBatteryLevel":
                let batteryLevel = self?.getBatteryLevel() ?? -1
                if batteryLevel >= 0 {
                    result(batteryLevel)
                } else {
                    result(
                        FlutterError(
                            code: "UNAVAILABLE",
                            message: "Battery level not available",
                            details: nil
                        )
                    )
                }
            case "startCharging":
                result(true)
            default:
                result(FlutterMethodNotImplemented)
            }
        }

        GeneratedPluginRegistrant.register(with: self)
        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }

    private func getBatteryLevel() -> Int {
        let device = UIDevice.current
        device.isBatteryMonitoringEnabled = true
        return Int(device.batteryLevel * 100)
    }
}

// Dart side
class SensorService {
  static const _eventChannel = EventChannel('com.dodatech/sensor');

  Stream<double> get accelerometerStream {
    return _eventChannel.receiveBroadcastStream().map(
      (event) => (event as num).toDouble(),
    );
  }

  Stream<Map<String, dynamic>> get locationStream {
    return _eventChannel
        .receiveBroadcastStream('location')
        .map((event) => event as Map<String, dynamic>);
  }
}

// Android side
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    
    EventChannel(
        flutterEngine.dartExecutor.binaryMessenger,
        "com.dodatech/sensor"
    ).setStreamHandler(
        SensorStreamHandler()
    )
}

class SensorStreamHandler : EventChannel.StreamHandler {
    private var sensorManager: SensorManager? = null
    private var sensorEventListener: SensorEventListener? = null

    override fun onListen(arguments: Any?, events: EventChannel.EventSink) {
        val context = // get context
        sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
        sensorEventListener = object : SensorEventListener {
            override fun onSensorChanged(event: SensorEvent) {
                events.success(event.values[0])
            }
            override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
        }
        sensorManager?.registerListener(
            sensorEventListener,
            sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
            SensorManager.SENSOR_DELAY_NORMAL
        )
    }

    override fun onCancel(arguments: Any?) {
        sensorManager?.unregisterListener(sensorEventListener)
    }
}

// Dart side
class PlatformMessages {
  static const _messageChannel = BasicMessageChannel<String>(
    'com.dodatech/messages',
    StringCodec(),
  );

  Future<String?> sendMessage(String message) async {
    try {
      return await _messageChannel.send(message);
    } on PlatformException catch (e) {
      print('Message error: ${e.message}');
      return null;
    }
  }

  Stream<String> get messageStream {
    return _messageChannel.receiveBroadcastStream().cast<String>();
  }
}

// Dart: send a complex object
final result = await _channel.invokeMethod('processUser', {
  'name': 'Alice',
  'age': 30,
  'address': {
    'street': '123 Main St',
    'city': 'Springfield',
    'zipCode': '12345',
  },
  'tags': ['premium', 'active'],
  'score': 95.5,
});

// Kotlin: receive and process
"processUser" -> {
    val data = call.arguments as Map<String, Any?>
    val name = data["name"] as String
    val age = data["age"] as Int
    val address = data["address"] as Map<String, Any?>
    val tags = data["tags"] as List<String>
    val score = data["score"] as Double
    
    // Process user data
    result.success(mapOf(
        "processed" to true,
        "userName" to name.uppercase()
    ))
}

// Dart side with detailed error handling
Future<dynamic> safeInvoke(String method, [dynamic arguments]) async {
  try {
    return await _channel.invokeMethod(method, arguments);
  } on MissingPluginException {
    print('Method $method not implemented on platform');
    return null;
  } on PlatformException catch (e) {
    print('Platform error: ${e.code} - ${e.message}');
    return null;
  } catch (e) {
    print('Unexpected error: $e');
    return null;
  }
}

// Kotlin side with specific error codes
result.error(
    "PERMISSION_DENIED",
    "Camera permission is required",
    null
)
result.error(
    "NOT_AVAILABLE",
    "Feature not available on this device",
    null
)

// lib/battery_plugin.dart
import 'package:flutter/services.dart';

class BatteryPlugin {
  static const _channel = MethodChannel('com.dodatech/battery');

  static Future<int> getBatteryLevel() async {
    return await _channel.invokeMethod<int>('getBatteryLevel') ?? -1;
  }
}

// In pubspec.yaml for plugin:
// flutter:
//   plugin:
//     platforms:
//       android:
//         package: com.dodatech.battery
//         pluginClass: BatteryPlugin
//       ios:
//         pluginClass: BatteryPlugin