Integrating Custom Native Code in Flutter Using Platform Channels

Bridging Flutter and Native Code: The Complete Platform Channels Guide

Flutter has revolutionized cross-platform development by offering near-native performance, a declarative UI paradigm, and a single codebase. However, there are times when you must break out of the Dart sandbox to access platform-specific features. This comprehensive flutter platform channels guide will walk you through the architecture, implementation, and best practices of bridging Flutter with native iOS (Swift) and Android (Kotlin) codebases. By understanding how to leverage these channels, you can build highly customized, high-performance applications without sacrificing the productivity benefits of a single codebase.

Whether you need to access low-level hardware APIs, integrate legacy enterprise SDKs, or execute performance-critical operations, writing custom native code flutter bridges is an essential skill for any professional mobile engineer.

Why Flutter Needs Native Integration (Hardware APIs, Legacy SDKs)

While we often discuss why Flutter is the premier choice for cross-platform development, its true power lies in its extensibility. Flutter does not compile your Dart code into native platform UI widgets; instead, it renders its own UI using the Impeller or Skia graphics engines. While this guarantees visual consistency across platforms, it also means that Flutter does not have direct, out-of-the-box access to the underlying operating system's non-UI APIs.

To interact with the host OS, Flutter relies on a message-passing architecture. Here are the primary scenarios where you will need to write custom native code:

Hardware APIs: Accessing specialized hardware components such as Bluetooth Low Energy (BLE) peripherals, custom camera sensors, biometrics (FaceID/Fingerprint), custom USB accessories, or Near Field Communication (NFC) chips.
Legacy SDKs: Integrating proprietary or third-party enterprise SDKs (e.g., specialized payment gateways, security wrappers, or local database engines) that only provide native Android (Java/Kotlin) and iOS (Objective-C/Swift) libraries.
OS-Specific Features: Utilizing platform-specific features like iOS App Widgets, Android Quick Settings tiles, system-level alarms, or deep integration with native OS settings.
Performance-Critical Tasks: Offloading heavy computational tasks—such as real-time image processing, complex cryptography, or low-level audio manipulation—to native execution environments where you can leverage platform-specific hardware acceleration (like Metal on iOS or RenderScript/Vulkan on Android).

As you follow this flutter platform channels guide, keep in mind that while platform channels are incredibly powerful, they introduce serialization overhead. They should be used strategically, keeping the boundary crossings minimal and data payloads optimized.

Understanding MethodChannel and EventChannel Architecture

At the core of Flutter's native extensibility is a flexible, asynchronous message-passing system. Flutter provides three primary types of channels to facilitate communication between Dart and the host platform:

MethodChannel: Designed for one-off, request-response style communication. This is analogous to a Remote Procedure Call (RPC). Dart invokes a method, and the native side executes code and returns a single result (or error) asynchronously.
EventChannel: Designed for continuous streams of data. This is ideal for observing platform events, such as physical sensor updates (accelerometer, gyroscope), battery status changes, network connectivity transitions, or real-time location tracking.
BasicMessageChannel: Designed for continuous, bidirectional message passing using custom codecs. It is less commonly used but highly valuable for streaming raw bytes or custom-serialized data structures.

The Architecture of a Platform Channel

The communication is asynchronous and bidirectional, though most commonly initiated by Dart. The following diagram illustrates how messages flow across the Dart-Native boundary:

+-------------------------------------------------------------------------+
|                             Dart / Flutter                              |
|                                                                         |
|   MethodChannel.invokeMethod() <=========> EventChannel.receive         |
+-------------------------------------------------------------------------+
                                     |
                                     | (BinaryMessenger / Serialization)
                                     v
+-------------------------------------------------------------------------+
|                            Platform Channel                             |
|                                                                         |
|   StandardMessageCodec (Maps Dart types to Swift/Kotlin native types)   |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                               Native Host                               |
|                                                                         |
|   Android (Kotlin/Java)                  iOS (Swift/Objective-C)        |
|   MethodCallHandler                      FlutterMethodChannel           |
|   StreamHandler                          FlutterEventChannel            |
+-------------------------------------------------------------------------+

Data Serialization and Codecs

When you send data across a channel, Flutter automatically serializes and deserializes the payload using the StandardMessageCodec. This codec supports efficient binary serialization of simple values. The table below outlines how types are mapped across the boundary:

Understanding this mapping is crucial. If you attempt to pass an unsupported complex Dart object directly across a channel, the execution will fail. You must first serialize the object into a Map<String, dynamic> (JSON-like structure) or a raw binary buffer before sending it.

Step-by-Step Tutorial: Writing Custom Native Code

To demonstrate swift kotlin integration flutter patterns, we will build a real-world, production-grade native integration. We will create a custom battery optimizer and monitoring utility that:

Retrieves the current battery level as a one-off request (MethodChannel).
Streams the real-time battery charging state (Charging, Discharging, Full) back to Dart (EventChannel).

Implementing Platform MethodChannel in Dart

In this section of our flutter platform channels guide, we will write the Dart interface. We will encapsulate our platform channel logic inside a clean, maintainable service class. This decouples our UI from the underlying platform channel implementation.

Create a new file named battery_service.dart:

import 'dart:async';
import 'package:flutter/services.dart';
 
/// Defines the charging states of the device.
enum BatteryStatus {
  charging,
  discharging,
  full,
  unknown,
}
 
class BatteryService {
  // Define unique channel names. Reverse-domain notation is highly recommended.
  static const MethodChannel _methodChannel = 
      MethodChannel('tech.vyrova.battery/methods');
  
  static const EventChannel _eventChannel = 
      EventChannel('tech.vyrova.battery/events');
 
  /// Fetches the current battery level as a percentage (0 to 100).
  /// Throws a [PlatformException] if the native call fails.
  Future<int> getBatteryLevel() async {
    try {
      // Invoke the native method 'getBatteryLevel'
      final int? level = await _methodChannel.invokeMethod<int>('getBatteryLevel');
      if (level == null) {
        throw PlatformException(
          code: 'UNAVAILABLE',
          message: 'Battery level returned null from native platform.',
        );
      }
      return level;
    } on PlatformException catch (e) {
      // Handle or rethrow platform-specific errors
      print('Failed to get battery level: ${e.message}');
      rethrow;
    }
  }
 
  /// Listens to real-time changes in the battery charging status.
  Stream<BatteryStatus> get batteryStatusStream {
    return _eventChannel.receiveBroadcastStream().map((dynamic event) {
      switch (event as String?) {
        case 'charging':
          return BatteryStatus.charging;
        case 'discharging':
          return BatteryStatus.discharging;
        case 'full':
          return BatteryStatus.full;
        default:
          return BatteryStatus.unknown;
      }
    });
  }
}

Writing Swift Code (iOS side)

Now, let's implement the iOS side of our swift kotlin integration flutter bridge. We will modify the AppDelegate.swift file located in your Flutter project's ios/Runner directory.

We will register both a FlutterMethodChannel and a FlutterEventChannel. To handle the event stream, we will implement the FlutterStreamHandler protocol.

Open ios/Runner/AppDelegate.swift and replace its contents with the following implementation:

import UIKit
import Flutter
 
@main
@objc class AppDelegate: FlutterAppDelegate, FlutterStreamHandler {
  
  private var eventSink: FlutterEventSink?
 
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    
    // 1. Set up the MethodChannel
    let methodChannel = FlutterMethodChannel(
      name: "tech.vyrova.battery/methods",
      binaryMessenger: controller.binaryMessenger
    )
    
    methodChannel.setMethodCallHandler({
      [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
      guard call.method == "getBatteryLevel" else {
        result(FlutterMethodNotImplemented)
        return
      }
      self?.receiveBatteryLevel(result: result)
    })
    
    // 2. Set up the EventChannel
    let eventChannel = FlutterEventChannel(
      name: "tech.vyrova.battery/events",
      binaryMessenger: controller.binaryMessenger
    )
    eventChannel.setStreamHandler(self)
    
    // Register plugins
    GeneratedPluginRegistrant.register(with: self)
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
 
  // MARK: - MethodChannel Handler
  private func receiveBatteryLevel(result: FlutterResult) {
    let device = UIDevice.current
    device.isBatteryMonitoringEnabled = true
    
    if device.batteryState == .unknown {
      result(FlutterError(
        code: "UNAVAILABLE",
        message: "Battery info unavailable on this device.",
        details: nil
      ))
    } else {
      // batteryLevel is returned as a float between 0.0 and 1.0
      let level = Int(device.batteryLevel * 100)
      result(level)
    }
  }
 
  // MARK: - FlutterStreamHandler Implementation
  public func onListen(
    withArguments arguments: Any?,
    eventSink events: @escaping FlutterEventSink
  ) -> FlutterError? {
    self.eventSink = events
    UIDevice.current.isBatteryMonitoringEnabled = true
    
    // Send initial state immediately
    sendBatteryStatusUpdate()
    
    // Register for battery state change notifications
    NotificationCenter.default.addObserver(
      self,
      selector: #selector(batteryStateDidChange),
      name: UIDevice.batteryStateDidChangeNotification,
      object: nil
    )
    
    return nil
  }
 
  public func onCancel(withArguments arguments: Any?) -> FlutterError? {
    NotificationCenter.default.removeObserver(
      self,
      name: UIDevice.batteryStateDidChangeNotification,
      object: nil
    )
    self.eventSink = nil
    return nil
  }
 
  @objc private func batteryStateDidChange(_ notification: Notification) {
    sendBatteryStatusUpdate()
  }
 
  private func sendBatteryStatusUpdate() {
    guard let eventSink = eventSink else { return }
    
    let state = UIDevice.current.batteryState
    var statusString = "unknown"
    
    switch state {
    case .charging:
      statusString = "charging"
    case .unplugged:
      statusString = "discharging"
    case .full:
      statusString = "full"
    default:
      statusString = "unknown"
    }
    
    eventSink(statusString)
  }
}

Writing Kotlin Code (Android side)

Next, we will implement the Android side of our methodchannel flutter integration. We will modify the MainActivity.kt file located in android/app/src/main/kotlin/your/package/name/MainActivity.kt.

We will override configureFlutterEngine to register our channels and implement a BroadcastReceiver to listen to system-wide battery changes.

package tech.vyrova.battery_example // Replace with your actual package name
 
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.BatteryManager
import android.os.Build
import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.EventChannel
import io.flutter.plugin.common.MethodChannel
 
class MainActivity: FlutterActivity() {
    private val METHOD_CHANNEL = "tech.vyrova.battery/methods"
    private val EVENT_CHANNEL = "tech.vyrova.battery/events"
 
    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
 
        // 1. Set up MethodChannel
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, METHOD_CHANNEL).setMethodCallHandler { call, result ->
            if (call.method == "getBatteryLevel") {
                val batteryLevel = getBatteryLevel()
 
                if (batteryLevel != -1) {
                    result.success(batteryLevel)
                } else {
                    result.error("UNAVAILABLE", "Battery level not available.", null)
                }
            } else {
                result.notImplemented()
            }
        }
 
        // 2. Set up EventChannel
        EventChannel(flutterEngine.dartExecutor.binaryMessenger, EVENT_CHANNEL).setStreamHandler(
            object : EventChannel.StreamHandler {
                private var batteryReceiver: BroadcastReceiver? = null
 
                override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
                    batteryReceiver = createBatteryReceiver(events)
                    registerReceiver(
                        batteryReceiver,
                        IntentFilter(Intent.ACTION_BATTERY_CHANGED)
                    )
                }
 
                override fun onCancel(arguments: Any?) {
                    unregisterReceiver(batteryReceiver)
                    batteryReceiver = null
                }
            }
        )
    }
 
    // MARK: - Helper Methods
    private fun getBatteryLevel(): Int {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
            batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
        } else {
            val intent = ContextWrapper(applicationContext).registerReceiver(
                null,
                IntentFilter(Intent.ACTION_BATTERY_CHANGED)
            )
            val level = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
            val scale = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
            if (level != -1 && scale != -1) {
                ((level.toFloat() / scale.toFloat()) * 100).toInt()
            } else {
                -1
            }
        }
    }
 
    private fun createBatteryReceiver(events: EventChannel.EventSink?): BroadcastReceiver {
        return object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                val status = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) ?: -1
                val statusString = when (status) {
                    BatteryManager.BATTERY_STATUS_CHARGING -> "charging"
                    BatteryManager.BATTERY_STATUS_DISCHARGING -> "discharging"
                    BatteryManager.BATTERY_STATUS_FULL -> "full"
                    else -> "unknown"
                }
                events?.success(statusString)
            }
        }
    }
}

Handling Threading and Background Services Across Native-Flutter Boundaries

One of the most common mistakes developers make when writing custom native code flutter bridges is ignoring threading models. By default, all platform channel invocations run on the platform's main thread (the UI thread).

If you execute a long-running, blocking operation (such as a large database query, network request, or image processing task) directly inside your MethodCallHandler on the main thread, you will freeze the Flutter UI, causing frame drops and a poor user experience.

Offloading Tasks to Background Threads

To prevent UI blocking, you must explicitly offload heavy tasks to background threads on the native side, and then dispatch the result back to the main thread before replying to Flutter.

Threading in Swift (iOS)

On iOS, you use Grand Central Dispatch (GCD) to move work off the main thread.

methodChannel.setMethodCallHandler({ (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
  if call.method == "heavyComputation" {
    // Dispatch to a background queue
    DispatchQueue.global(qos: .userInitiated).async {
      let computationResult = self.performHeavyTask()
      
      // Dispatch back to the main queue to return the result to Flutter
      DispatchQueue.main.async {
        result(computationResult)
      }
    }
  }
})

Threading in Kotlin (Android)

On Android, you can use Kotlin Coroutines or Executors to handle background tasks safely.

import kotlinx.coroutines.*
 
// Define a coroutine scope bound to the Main thread
private val activityScope = CoroutineScope(Dispatchers.Main)
 
MethodChannel(flutterEngine.dartExecutor.binaryMessenger, METHOD_CHANNEL).setMethodCallHandler { call, result ->
    if (call.method == "heavyComputation") {
        // Launch a coroutine on the Main thread
        activityScope.launch {
            // Switch context to IO thread for background work
            val computationResult = withContext(Dispatchers.IO) {
                performHeavyTask()
            }
            // Return result on the Main thread
            result.success(computationResult)
        }
    }
}

Background Execution and Headless Engines

If you need to run Dart code in response to a native background event (e.g., a geofencing trigger, silent push notification, or system alarm) when the main Flutter app is not running, you must use Flutter Background Execution.

This involves starting a headless Flutter engine instance from the native side using FlutterEngineGroup or DartExecutor. This allows your native background service to invoke Dart functions directly, even when the UI is completely terminated.

Debugging and Testing Platform Channel Bridges

Building robust platform channels requires a disciplined approach to debugging and testing. Because your code spans three different runtimes (Dart, Swift, and Kotlin), traditional single-IDE debugging is often insufficient.

Debugging Strategies

Dual-IDE Debugging:
- Open your Flutter project in VS Code or Android Studio for Dart debugging.
- Open the ios folder in Xcode to debug Swift code. You can set breakpoints directly in your AppDelegate.swift and run the app on a simulator or physical device from Xcode.
- Open the android folder in a separate Android Studio window to debug Kotlin code. Use the "Attach Debugger to Android Process" button to attach to your running Flutter app.
Unified Logging:
- Use native logging APIs that stream directly to your console.
- In Swift: Use os_log or print().
- In Kotlin: Use android.util.Log.d("TAG", "message").
- In Dart: Use developer.log() from dart:developer.

Unit Testing Platform Channels in Dart

You do not need a physical device or emulator to test your Dart-side platform channel logic. Flutter provides a powerful testing utility called TestDefaultBinaryMessengerBinding to mock native channel responses.

Here is how you can write a unit test for our BatteryService:

import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:your_app/services/battery_service.dart'; // Adjust path
 
void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
 
  group('BatteryService Tests', () {
    const MethodChannel channel = MethodChannel('tech.vyrova.battery/methods');
    late BatteryService batteryService;
    final List<MethodCall> log = <MethodCall>[];
 
    setUp(() {
      batteryService = BatteryService();
      
      // Register a mock handler for the MethodChannel
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(channel, (MethodCall methodCall) async {
        log.add(methodCall);
        if (methodCall.method == 'getBatteryLevel') {
          return 85; // Mock return value
        }
        return null;
      });
    });
 
    tearDown(() {
      log.clear();
      // Clean up the mock handler
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(channel, null);
    });
 
    test('getBatteryLevel returns correct value and logs call', () async {
      final int level = await batteryService.getBatteryLevel();
      
      expect(level, equals(85));
      expect(log, hasLength(1));
      expect(log.first.method, equals('getBatteryLevel'));
    });
  });
}

By mocking the binary messenger, you can verify that your Dart code correctly formats arguments, handles native return values, and gracefully catches PlatformException errors under various simulated failure states.

Looking for Premium Mobile App Developers?

We build high-performance, native-grade cross-platform apps using Flutter and React Native. Let's discuss your product goals.

Get a Mobile Dev Quote

Conclusion

Integrating custom native code in Flutter using platform channels is a vital technique for unlocking the full potential of mobile operating systems. By understanding the underlying architecture of MethodChannel and EventChannel, mapping data types correctly, handling threading models responsibly, and implementing robust debugging and testing strategies, you can build seamless, high-performance bridges between Dart and native APIs.

We hope this flutter platform channels guide has given you the confidence and technical depth required to tackle complex native integrations in your next enterprise-grade Flutter application. Keep your channels clean, minimize serialization overhead, and always offload heavy computations to background threads to ensure your UI remains buttery smooth.

Bridging Flutter and Native Code: The Complete Platform Channels Guide

Why Flutter Needs Native Integration (Hardware APIs, Legacy SDKs)

To interact with the host OS, Flutter relies on a message-passing architecture. Here are the primary scenarios where you will need to write custom native code:

Hardware APIs: Accessing specialized hardware components such as Bluetooth Low Energy (BLE) peripherals, custom camera sensors, biometrics (FaceID/Fingerprint), custom USB accessories, or Near Field Communication (NFC) chips.
Legacy SDKs: Integrating proprietary or third-party enterprise SDKs (e.g., specialized payment gateways, security wrappers, or local database engines) that only provide native Android (Java/Kotlin) and iOS (Objective-C/Swift) libraries.
OS-Specific Features: Utilizing platform-specific features like iOS App Widgets, Android Quick Settings tiles, system-level alarms, or deep integration with native OS settings.
Performance-Critical Tasks: Offloading heavy computational tasks—such as real-time image processing, complex cryptography, or low-level audio manipulation—to native execution environments where you can leverage platform-specific hardware acceleration (like Metal on iOS or RenderScript/Vulkan on Android).

Understanding MethodChannel and EventChannel Architecture

MethodChannel: Designed for one-off, request-response style communication. This is analogous to a Remote Procedure Call (RPC). Dart invokes a method, and the native side executes code and returns a single result (or error) asynchronously.
EventChannel: Designed for continuous streams of data. This is ideal for observing platform events, such as physical sensor updates (accelerometer, gyroscope), battery status changes, network connectivity transitions, or real-time location tracking.
BasicMessageChannel: Designed for continuous, bidirectional message passing using custom codecs. It is less commonly used but highly valuable for streaming raw bytes or custom-serialized data structures.

The Architecture of a Platform Channel

The communication is asynchronous and bidirectional, though most commonly initiated by Dart. The following diagram illustrates how messages flow across the Dart-Native boundary:

+-------------------------------------------------------------------------+
|                             Dart / Flutter                              |
|                                                                         |
|   MethodChannel.invokeMethod() <=========> EventChannel.receive         |
+-------------------------------------------------------------------------+
                                     |
                                     | (BinaryMessenger / Serialization)
                                     v
+-------------------------------------------------------------------------+
|                            Platform Channel                             |
|                                                                         |
|   StandardMessageCodec (Maps Dart types to Swift/Kotlin native types)   |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                               Native Host                               |
|                                                                         |
|   Android (Kotlin/Java)                  iOS (Swift/Objective-C)        |
|   MethodCallHandler                      FlutterMethodChannel           |
|   StreamHandler                          FlutterEventChannel            |
+-------------------------------------------------------------------------+

Data Serialization and Codecs

Step-by-Step Tutorial: Writing Custom Native Code

To demonstrate swift kotlin integration flutter patterns, we will build a real-world, production-grade native integration. We will create a custom battery optimizer and monitoring utility that:

Retrieves the current battery level as a one-off request (MethodChannel).
Streams the real-time battery charging state (Charging, Discharging, Full) back to Dart (EventChannel).

Implementing Platform MethodChannel in Dart

Create a new file named battery_service.dart:

import 'dart:async';
import 'package:flutter/services.dart';
 
/// Defines the charging states of the device.
enum BatteryStatus {
  charging,
  discharging,
  full,
  unknown,
}
 
class BatteryService {
  // Define unique channel names. Reverse-domain notation is highly recommended.
  static const MethodChannel _methodChannel = 
      MethodChannel('tech.vyrova.battery/methods');
  
  static const EventChannel _eventChannel = 
      EventChannel('tech.vyrova.battery/events');
 
  /// Fetches the current battery level as a percentage (0 to 100).
  /// Throws a [PlatformException] if the native call fails.
  Future<int> getBatteryLevel() async {
    try {
      // Invoke the native method 'getBatteryLevel'
      final int? level = await _methodChannel.invokeMethod<int>('getBatteryLevel');
      if (level == null) {
        throw PlatformException(
          code: 'UNAVAILABLE',
          message: 'Battery level returned null from native platform.',
        );
      }
      return level;
    } on PlatformException catch (e) {
      // Handle or rethrow platform-specific errors
      print('Failed to get battery level: ${e.message}');
      rethrow;
    }
  }
 
  /// Listens to real-time changes in the battery charging status.
  Stream<BatteryStatus> get batteryStatusStream {
    return _eventChannel.receiveBroadcastStream().map((dynamic event) {
      switch (event as String?) {
        case 'charging':
          return BatteryStatus.charging;
        case 'discharging':
          return BatteryStatus.discharging;
        case 'full':
          return BatteryStatus.full;
        default:
          return BatteryStatus.unknown;
      }
    });
  }
}

Writing Swift Code (iOS side)

Now, let's implement the iOS side of our swift kotlin integration flutter bridge. We will modify the AppDelegate.swift file located in your Flutter project's ios/Runner directory.

We will register both a FlutterMethodChannel and a FlutterEventChannel. To handle the event stream, we will implement the FlutterStreamHandler protocol.

Open ios/Runner/AppDelegate.swift and replace its contents with the following implementation:

import UIKit
import Flutter
 
@main
@objc class AppDelegate: FlutterAppDelegate, FlutterStreamHandler {
  
  private var eventSink: FlutterEventSink?
 
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    
    // 1. Set up the MethodChannel
    let methodChannel = FlutterMethodChannel(
      name: "tech.vyrova.battery/methods",
      binaryMessenger: controller.binaryMessenger
    )
    
    methodChannel.setMethodCallHandler({
      [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
      guard call.method == "getBatteryLevel" else {
        result(FlutterMethodNotImplemented)
        return
      }
      self?.receiveBatteryLevel(result: result)
    })
    
    // 2. Set up the EventChannel
    let eventChannel = FlutterEventChannel(
      name: "tech.vyrova.battery/events",
      binaryMessenger: controller.binaryMessenger
    )
    eventChannel.setStreamHandler(self)
    
    // Register plugins
    GeneratedPluginRegistrant.register(with: self)
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
 
  // MARK: - MethodChannel Handler
  private func receiveBatteryLevel(result: FlutterResult) {
    let device = UIDevice.current
    device.isBatteryMonitoringEnabled = true
    
    if device.batteryState == .unknown {
      result(FlutterError(
        code: "UNAVAILABLE",
        message: "Battery info unavailable on this device.",
        details: nil
      ))
    } else {
      // batteryLevel is returned as a float between 0.0 and 1.0
      let level = Int(device.batteryLevel * 100)
      result(level)
    }
  }
 
  // MARK: - FlutterStreamHandler Implementation
  public func onListen(
    withArguments arguments: Any?,
    eventSink events: @escaping FlutterEventSink
  ) -> FlutterError? {
    self.eventSink = events
    UIDevice.current.isBatteryMonitoringEnabled = true
    
    // Send initial state immediately
    sendBatteryStatusUpdate()
    
    // Register for battery state change notifications
    NotificationCenter.default.addObserver(
      self,
      selector: #selector(batteryStateDidChange),
      name: UIDevice.batteryStateDidChangeNotification,
      object: nil
    )
    
    return nil
  }
 
  public func onCancel(withArguments arguments: Any?) -> FlutterError? {
    NotificationCenter.default.removeObserver(
      self,
      name: UIDevice.batteryStateDidChangeNotification,
      object: nil
    )
    self.eventSink = nil
    return nil
  }
 
  @objc private func batteryStateDidChange(_ notification: Notification) {
    sendBatteryStatusUpdate()
  }
 
  private func sendBatteryStatusUpdate() {
    guard let eventSink = eventSink else { return }
    
    let state = UIDevice.current.batteryState
    var statusString = "unknown"
    
    switch state {
    case .charging:
      statusString = "charging"
    case .unplugged:
      statusString = "discharging"
    case .full:
      statusString = "full"
    default:
      statusString = "unknown"
    }
    
    eventSink(statusString)
  }
}

Writing Kotlin Code (Android side)

We will override configureFlutterEngine to register our channels and implement a BroadcastReceiver to listen to system-wide battery changes.

package tech.vyrova.battery_example // Replace with your actual package name
 
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.BatteryManager
import android.os.Build
import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.EventChannel
import io.flutter.plugin.common.MethodChannel
 
class MainActivity: FlutterActivity() {
    private val METHOD_CHANNEL = "tech.vyrova.battery/methods"
    private val EVENT_CHANNEL = "tech.vyrova.battery/events"
 
    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
 
        // 1. Set up MethodChannel
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, METHOD_CHANNEL).setMethodCallHandler { call, result ->
            if (call.method == "getBatteryLevel") {
                val batteryLevel = getBatteryLevel()
 
                if (batteryLevel != -1) {
                    result.success(batteryLevel)
                } else {
                    result.error("UNAVAILABLE", "Battery level not available.", null)
                }
            } else {
                result.notImplemented()
            }
        }
 
        // 2. Set up EventChannel
        EventChannel(flutterEngine.dartExecutor.binaryMessenger, EVENT_CHANNEL).setStreamHandler(
            object : EventChannel.StreamHandler {
                private var batteryReceiver: BroadcastReceiver? = null
 
                override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
                    batteryReceiver = createBatteryReceiver(events)
                    registerReceiver(
                        batteryReceiver,
                        IntentFilter(Intent.ACTION_BATTERY_CHANGED)
                    )
                }
 
                override fun onCancel(arguments: Any?) {
                    unregisterReceiver(batteryReceiver)
                    batteryReceiver = null
                }
            }
        )
    }
 
    // MARK: - Helper Methods
    private fun getBatteryLevel(): Int {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
            batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
        } else {
            val intent = ContextWrapper(applicationContext).registerReceiver(
                null,
                IntentFilter(Intent.ACTION_BATTERY_CHANGED)
            )
            val level = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
            val scale = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
            if (level != -1 && scale != -1) {
                ((level.toFloat() / scale.toFloat()) * 100).toInt()
            } else {
                -1
            }
        }
    }
 
    private fun createBatteryReceiver(events: EventChannel.EventSink?): BroadcastReceiver {
        return object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                val status = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) ?: -1
                val statusString = when (status) {
                    BatteryManager.BATTERY_STATUS_CHARGING -> "charging"
                    BatteryManager.BATTERY_STATUS_DISCHARGING -> "discharging"
                    BatteryManager.BATTERY_STATUS_FULL -> "full"
                    else -> "unknown"
                }
                events?.success(statusString)
            }
        }
    }
}

Handling Threading and Background Services Across Native-Flutter Boundaries

Offloading Tasks to Background Threads

To prevent UI blocking, you must explicitly offload heavy tasks to background threads on the native side, and then dispatch the result back to the main thread before replying to Flutter.

Threading in Swift (iOS)

On iOS, you use Grand Central Dispatch (GCD) to move work off the main thread.

methodChannel.setMethodCallHandler({ (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
  if call.method == "heavyComputation" {
    // Dispatch to a background queue
    DispatchQueue.global(qos: .userInitiated).async {
      let computationResult = self.performHeavyTask()
      
      // Dispatch back to the main queue to return the result to Flutter
      DispatchQueue.main.async {
        result(computationResult)
      }
    }
  }
})

Threading in Kotlin (Android)

On Android, you can use Kotlin Coroutines or Executors to handle background tasks safely.

import kotlinx.coroutines.*
 
// Define a coroutine scope bound to the Main thread
private val activityScope = CoroutineScope(Dispatchers.Main)
 
MethodChannel(flutterEngine.dartExecutor.binaryMessenger, METHOD_CHANNEL).setMethodCallHandler { call, result ->
    if (call.method == "heavyComputation") {
        // Launch a coroutine on the Main thread
        activityScope.launch {
            // Switch context to IO thread for background work
            val computationResult = withContext(Dispatchers.IO) {
                performHeavyTask()
            }
            // Return result on the Main thread
            result.success(computationResult)
        }
    }
}

Background Execution and Headless Engines

Debugging and Testing Platform Channel Bridges

Debugging Strategies

Dual-IDE Debugging:
- Open your Flutter project in VS Code or Android Studio for Dart debugging.
- Open the ios folder in Xcode to debug Swift code. You can set breakpoints directly in your AppDelegate.swift and run the app on a simulator or physical device from Xcode.
- Open the android folder in a separate Android Studio window to debug Kotlin code. Use the "Attach Debugger to Android Process" button to attach to your running Flutter app.
Unified Logging:
- Use native logging APIs that stream directly to your console.
- In Swift: Use os_log or print().
- In Kotlin: Use android.util.Log.d("TAG", "message").
- In Dart: Use developer.log() from dart:developer.

Unit Testing Platform Channels in Dart

Here is how you can write a unit test for our BatteryService:

import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:your_app/services/battery_service.dart'; // Adjust path
 
void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
 
  group('BatteryService Tests', () {
    const MethodChannel channel = MethodChannel('tech.vyrova.battery/methods');
    late BatteryService batteryService;
    final List<MethodCall> log = <MethodCall>[];
 
    setUp(() {
      batteryService = BatteryService();
      
      // Register a mock handler for the MethodChannel
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(channel, (MethodCall methodCall) async {
        log.add(methodCall);
        if (methodCall.method == 'getBatteryLevel') {
          return 85; // Mock return value
        }
        return null;
      });
    });
 
    tearDown(() {
      log.clear();
      // Clean up the mock handler
      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
          .setMockMethodCallHandler(channel, null);
    });
 
    test('getBatteryLevel returns correct value and logs call', () async {
      final int level = await batteryService.getBatteryLevel();
      
      expect(level, equals(85));
      expect(log, hasLength(1));
      expect(log.first.method, equals('getBatteryLevel'));
    });
  });
}

Looking for Premium Mobile App Developers?

We build high-performance, native-grade cross-platform apps using Flutter and React Native. Let's discuss your product goals.

Get a Mobile Dev Quote

Bridging Flutter and Native Code: The Complete Platform Channels Guide

Why Flutter Needs Native Integration (Hardware APIs, Legacy SDKs)

Understanding MethodChannel and EventChannel Architecture

The Architecture of a Platform Channel

Data Serialization and Codecs

Step-by-Step Tutorial: Writing Custom Native Code

Implementing Platform MethodChannel in Dart

Writing Swift Code (iOS side)

Writing Kotlin Code (Android side)

Handling Threading and Background Services Across Native-Flutter Boundaries

Offloading Tasks to Background Threads

Threading in Swift (iOS)

Threading in Kotlin (Android)

Background Execution and Headless Engines

Debugging and Testing Platform Channel Bridges

Debugging Strategies

Unit Testing Platform Channels in Dart

Looking for Premium Mobile App Developers?

Conclusion

Related Articles

Setting Up CI/CD for Flutter Apps With Codemagic

Deploying Flutter Apps to Apple App Store and Google Play

Flutter Performance Optimization: How to Build Lag-Free Apps

Bridging Flutter and Native Code: The Complete Platform Channels Guide

Why Flutter Needs Native Integration (Hardware APIs, Legacy SDKs)

Understanding MethodChannel and EventChannel Architecture

The Architecture of a Platform Channel

Data Serialization and Codecs

Step-by-Step Tutorial: Writing Custom Native Code

Implementing Platform MethodChannel in Dart

Writing Swift Code (iOS side)

Writing Kotlin Code (Android side)

Handling Threading and Background Services Across Native-Flutter Boundaries

Offloading Tasks to Background Threads

Threading in Swift (iOS)

Threading in Kotlin (Android)

Background Execution and Headless Engines

Debugging and Testing Platform Channel Bridges

Debugging Strategies

Unit Testing Platform Channels in Dart

Looking for Premium Mobile App Developers?

Conclusion

Related Articles

Setting Up CI/CD for Flutter Apps With Codemagic

Deploying Flutter Apps to Apple App Store and Google Play

Flutter Performance Optimization: How to Build Lag-Free Apps