Working with Platform Channels for Native Integration in Flutter

Flutter’s strength lies in its ability to create beautiful and performant cross-platform applications from a single codebase. However, there are times when you need to access platform-specific features that aren’t directly available through Flutter’s framework. This is where Platform Channels come in, allowing you to communicate directly with native code on iOS (Swift/Objective-C) and Android (Kotlin/Java).

What are Platform Channels?

Platform Channels are Flutter’s mechanism for establishing communication pipes between Dart code and native platform code. They provide a way to invoke native methods and receive results back in your Flutter app.

Why Use Platform Channels?

• Accessing Platform-Specific Features: Integrate functionalities like accessing the camera roll, working with sensors, using native libraries, and more.
• Performance Optimization: Delegate performance-critical tasks to native code when needed.
• Integrating with Existing Native Codebases: Leverage existing native components and modules in your Flutter application.

How to Use Platform Channels

Platform Channels involve code on both the Flutter (Dart) side and the native (Android/iOS) side. Let’s walk through the process of setting up a simple platform channel.

Step 1: Defining the Channel

First, you need to define a unique name for your platform channel in your Flutter code. This name acts as an identifier for communication.

import 'package:flutter/services.dart';

const platform = MethodChannel('your_channel_name');

Step 2: Invoking a Native Method

Next, use the invokeMethod method to call a native function through the channel. Pass the name of the method you want to invoke and any arguments as parameters.

Future getPlatformVersion() async {
  String version = "";
  try {
    version = await platform.invokeMethod('getPlatformVersion');
  } on PlatformException catch (e) {
    print("Failed to get platform version: '${e.message}'.");
  }
  return version;
}

Step 3: Implementing the Native Method (Android – Kotlin)

On the Android side, modify your MainActivity.kt file to handle method calls on the specified channel. Ensure the channel name matches the one used in Dart.

import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import android.os.Build

class MainActivity: FlutterActivity() {
    private val CHANNEL = "your_channel_name"

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
            call, result ->
            if (call.method == "getPlatformVersion") {
                result.success("Android ${Build.VERSION.RELEASE}")
            } else {
                result.notImplemented()
            }
        }
    }
}

Step 4: Implementing the Native Method (iOS – Swift)

On the iOS side, edit your AppDelegate.swift file. Again, the channel name should correspond to the name used in Dart.

import UIKit
import Flutter

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    let METHOD_CHANNEL = "your_channel_name"
    let channel = FlutterMethodChannel(name: METHOD_CHANNEL,
                                              binaryMessenger: controller.binaryMessenger)
    channel.setMethodCallHandler({
      (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
      if call.method == "getPlatformVersion" {
        result("iOS " + UIDevice.current.systemVersion)
      } else {
        result(FlutterMethodNotImplemented)
      }
    })

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

Step 5: Using the Result in Flutter

Back in your Flutter code, you can use the result returned from the native method to update the UI or perform other actions.

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State {
  String _platformVersion = 'Unknown';

  @override
  void initState() {
    super.initState();
    getPlatformVersion().then((value) {
      setState(() {
        _platformVersion = value;
      });
    });
  }

  Future getPlatformVersion() async {
    // Code from Step 2 here...
    String version = "";
    try {
      version = await platform.invokeMethod('getPlatformVersion');
    } on PlatformException catch (e) {
      print("Failed to get platform version: '${e.message}'.");
    }
    return version;
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Platform Channel Example'),
        ),
        body: Center(
          child: Text('Running on: $_platformVersion'),
        ),
      ),
    );
  }
}

Passing Arguments Through Platform Channels

You can pass arguments from Flutter to native code. Here’s an example:

Dart Code:

Future addTwoNumbers(int a, int b) async {
  int sum = 0;
  try {
    sum = await platform.invokeMethod('addTwoNumbers', {'a': a, 'b': b});
  } on PlatformException catch (e) {
    print("Failed to add numbers: '${e.message}'.");
  }
  return sum;
}

Kotlin Code (Android):

MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
    call, result ->
    if (call.method == "addTwoNumbers") {
        val a = call.argument("a") ?: 0
        val b = call.argument("b") ?: 0
        result.success(a + b)
    } else {
        result.notImplemented()
    }
}

Swift Code (iOS):

channel.setMethodCallHandler({
    (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
    if call.method == "addTwoNumbers" {
        let args = call.arguments as? Dictionary
        let a = args?["a"] ?? 0
        let b = args?["b"] ?? 0
        result(a + b)
    } else {
        result(FlutterMethodNotImplemented)
    }
})

Error Handling

Always wrap the platform channel invocation in a try-catch block to handle potential errors gracefully. Check for PlatformException to handle errors specific to channel invocation failures.

Considerations

• Channel Name: Ensure channel names are unique to avoid conflicts between different plugins or native modules.
• Data Types: Platform channels support primitive data types, Lists, and Maps. Make sure the data types are compatible on both sides of the channel.
• Asynchronous Nature: Method invocations are asynchronous, so be mindful of using async/await when dealing with results.

Conclusion

Platform Channels offer a powerful way to integrate native functionality into your Flutter applications. By understanding the communication mechanism and properly implementing the native and Dart sides, you can bridge the gap between cross-platform development and platform-specific features. This flexibility makes Flutter a versatile framework for building complex, high-performance applications.