Method Channels in Flutter

What are Method Channels in Flutter?

• Communication Bridge: Method Channels are a powerful mechanism in Flutter that allow you to communicate between your Flutter application and the underlying native platform (Android, iOS, macOS, etc.). nbsp;
• Two-Way Communication: They enable bidirectional communication, meaning you can: Invoke native code from Flutter: Call methods implemented in the native platform (e.g., access device sensors, use platform-specific APIs). nbsp; Invoke Flutter code from native: Trigger actions or updates within your Flutter application from the native side.
• How Method Channels Work:

1.Channel Definition:

• You define a unique channel name (e.g., 'com.example.my_app/my_channel') in both your Flutter code and the corresponding native code (Java/Kotlin for Android, Swift/Objective-C for iOS). This channel acts as a communication path.

2.Method Invocation:

• Flutter to Native: In your Flutter code, use the MethodChannel class and its invokeMethod() function to send a message (method name and any necessary arguments) to the native platform.
• Native to Flutter: In your native code, listen for incoming messages on the specified channel. When a message arrives, handle it appropriately and send any necessary results back to the Flutter side.

3.Data Exchange:

• Data is exchanged between Flutter and native platforms using a standardized format (typically JSON).
• You can pass various data types, such as: Basic types (int, double, String, bool) Lists Maps Custom objects (by serializing them to JSON)

4.Result Handling:

• The native code can send a result back to the Flutter code.
• Flutter can handle the result and update the UI or perform other actions accordingly.

Example:

Dart

import 'package:flutter/services.dart';

class MyPlugin {
  static const platform = MethodChannel('com.example.my_app/my_channel');

  static Future<String?> getPlatformVersion() async {
    try {
      final String? version = await platform.invokeMethod('getPlatformVersion');
      return version;
    } on PlatformException catch (e) {
      return 'Failed to get platform version.';
    }
  }
}        

Native Code (Android - Kotlin):

Kotlin

import androidx.annotation.NonNull;
import io.flutter.embedding.engine.FlutterEngine;
import io.flutter.plugin.common.MethodCall;
import io.flutter.plugin.common.MethodChannel;
import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
import io.flutter.plugin.common.MethodChannel.Result;

class MyPlugin: MethodCallHandler {
    private val channel: MethodChannel

    constructor(flutterEngine: FlutterEngine) {
        channel = MethodChannel(flutterEngine.dartExecutor, "com.example.my_app/my_channel")
        channel.setMethodCallHandler(this)
    }

    override fun onMethodCall(@NonNull call: MethodCall, @NonNull result: Result) {
        if (call.method == "getPlatformVersion") {
            result.success("Android ${android.os.Build.VERSION.release}")
        } else {
            result.notImplemented()
        }
    }
}        

iOS (Swift):

Swift

import Flutter

public class SwiftMethodHandler: NSObject, FlutterPlugin {
  public static func register(with registrar: FlutterPluginRegistrar) {
    let channel = FlutterMethodChannel(name: "com.example.my_app/my_channel", binaryMessenger: registrar.messenger())
    let instance = SwiftMethodHandler()
    registrar.addMethodCallDelegate(instance, channel: channel)
  }

  public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
    if (call.method == "getPlatformVersion") {
      result("iOS " + UIDevice.current.systemVersion)
    } else {
      result(FlutterMethodNotImplemented)
    }
  }
}        

Key Benefits of Method Channels:

• Platform Interoperability: Access native platform features and libraries not directly available in Flutter.
• Code Reusability: Share common logic between platforms.
• Flexibility: Supports various communication patterns and data exchange scenarios.
• Maintainability: Separates platform-specific code from your Flutter application.

By effectively using Method Channels, you can create powerful and flexible Flutter applications that seamlessly integrate with the underlying native platforms.