Build 10x products in minutes by chatting with AI - beyond just a prototype.
Topics
When developing apps with Flutter, one of the key challenges is dealing with platform channels. They act as a bridge between Dart and the native programming language of your host platform, such as Android or iOS. As a developer, your Flutter app will often need to communicate efficiently with platform-specific APIs; hence, understanding Flutter platform channels is crucial.
In this blog, we aim to explore and dissect the Flutter Platform Channel - the unsung hero that allows Flutter developers to leverage the full potential of native code within their apps.
Flutter platform channels are logically separated communication channels that provide a mechanism to perform asynchronous message passing between Dart and native Android or iOS code. At its heart, it's a conduit for your Flutter app to talk to native components and leverage platform-specific APIs.
Flutters offers three types of platform channels for developers to utilize:
We will explore each one in turn, providing examples, use cases, and technical intricacies where applicable.
By the end of this blog, you'll be adept at employing method channels, event channels, and BasicMessageChannels in your Flutter projects.
Let’s commence with an in-depth study of the Flutter MethodChannel.
The MethodChannel in a Flutter platform channel is primarily for sending messages from Dart to a host platform and getting the results back. It makes integrating platform-specific APIs or libraries with your Flutter app an absolute breeze.
A MethodChannel provides a transport layer for constant and reliable communication between Dart and a host platform's native code. While we illustrate an example, keep in mind the channel name. The channel name is crucial as it should be identical both in the Dart code and the equivalent native code, whether it be Swift, Objective C, or Kotlin code.
// Dart Code const platform = const MethodChannel('flutter.native/helper'); // Kotlin Code val channel = MethodChannel(flutterView, "flutter.native/helper")
The MethodChannel facilitates communication between Dart and the native platform on which the Flutter app runs. Messages and responses are passed asynchronously, ensuring the user interface remains responsive.
One thing that developers cherish about the Flutter MethodChannel is the "named method calls" mechanism. It sends messages using method calls and then receives a response on the Dart side.
Technically, method channels use a standard message codec, providing efficient binary serialization of simple JSON-like values, such as strings, booleans, lists, maps, and UTF8-encoded byte buffers.
An essential aspect of MethodChannel to remember is its 'one-to-one' message-passing property. With asynchronous message passing, you need to ensure that the response of a message is sent before another one can be transmitted.
We will further explore the implementation of method channels and the intricacies of using them effectively. But first, let's broach another significant concept - the Dart Method Call Handler.
A Dart method call handler is a necessary component when operating with method channels. It appoints a function responsible for receiving method calls and giving appropriate responses.
Upon initiating a MethodChannel, it is imperative to set up a method call handler for receiving method calls from the host platform. Method calls are event-driven, i.e., only activated when a specific event occurs on the platform. Events could range from a user interaction, like a button press, to system events, such as receiving a push notification.
Here is a simplified demonstration of initializing a method call handler in a Flutter app:
In the Flutter code, we combined the method channel object with a setMethodCallHandler function. In the asynchronous function, we can switch different cases based on the type of call.method received from the native code. If the method name from the host platform matches the case, Dart returns a string "Hello from Dart!". For unrecognized methods, a PlatformException with the "unknown_method" error message is thrown.
Understanding how a Dart method call handler operates is central to working effectively with Flutter's powerful platform channels.
Just like a MethodChannel, an EventChannel is another form of platform channel in Flutter that cements the link between Dart and your host platform's native programming language. However, one key difference differentiating it from MethodChannel is its ability to communicate continuously from a host platform to Dart.
An EventChannel is an excellent choice when you need to observe platform-side events and reflect changes in your Flutter app. It is ideal for scenarios like listening to sensor data, receiving platform notifications, or gathering information from third-party SDKs.
The following snippet demonstrates an example of EventChannel in Swift code:
In the above example, we initiated an instance of the FlutterEventChannelwith the same channel name as in the Dart code. Then, we set up an event stream handler to handle and process the incoming events.
Understanding EventChannel is crucial for developing applications that require continuous or event-driven communication with platform-specific native code.
Next, let's move forward and learn about the third type of channel in the Flutter platform channel – the BasicMessageChannel.
A BasicMessageChannel is another means of communication in the Flutter platform channel. It varies from the MethodChannel in that it permits communication in both directions - from Dart to the host platform and vice-versa, lending itself well for use cases where bidirectional communication is needed without getting responses or results.
However, it doesn't support directly returning a result or having an event stream, such as method calls or event channels. It mainly deals with a continuous chain of distinct messages, making it the right choice to broadcast messages from your native code to Dart or the reverse direction.
Here is an example of how you can initiate a BasicMessageChannel:
In this example, we defined StandardMessageCodec for serializing and deserializing messages into binary form. The messages include simple JSON-like values and UTF8-encoded byte buffers.
Thus, BasicMessageChannel offers you a straightforward and efficient communication channel, aiding in seamless message transmission in your Flutter apps downstream as well as upstream.
With that, we have covered an overview of the platform channels in Flutter. Now, we will go over how you can set up these Flutter platform channels in your project.
Creating a platform channel involves setting up the platform channel in the Dart code and then configuring the platform-specific code to use the same channel for communication. Here are the basic steps to set this up:
Step 1: Initialize a platform channel in Dart Start by initializing a MethodChannel (or EventChannel or BasicMessageChannel, as per your requirements) in your Dart code. You would need to specify a unique channel name.
Step 2: Setup the platform-specific code Once the platform channel is set up in Dart, you would now have to set up the platform-specific code on Android and iOS. The channel name and type should coincide on each platform for successful communication.
On Android
Navigate to the Android folder inside your Flutter project, edit the MainActivity file, and specify the channel name and logic for what should occur when a method call is made on this channel.
In this Kotlin code snippet, we've created a new instance of MethodChannel and used the same name as in our Dart code. Then, we named our method and instructed what should occur when this method is invoked from the Dart side.
On iOS
Open your Flutter project using Xcode or any other preferred iOS developer tool. In your application delegate (AppDelegate.swift), add a similar code to what we added in the Android file.
In this Swift code snippet, we set up the MethodChannel with the same name "flutter.native/helper" and outlined what the app should return when the method MethodName is invoked from the Dart side.
After successfully setting up your platform channels in your Flutter app and a requisite Android or iOS development environment, you ought to be able to send and receive messages across Dart and native code seamlessly.
Now that we understand the concept of method channels, let's take a look at a practical example where MethodChannel is utilized in a Flutter app. This example demonstrates the purpose and importance of MethodChannel.
Let's say we have a Flutter app, and we need to access the battery level of the device. This is a piece of information that Flutter's native framework doesn't inherently provide. Therefore, we must access this platform-specific native code through our Flutter platform channel that utilizes the MethodChannel.
Firstly, let's create a new MethodChannel in our Dart file, then we will invoke a method to fetch the battery level.
In the Dart code, we create a channel with MethodChannel and name it 'flutter.native/helper'. Then, a getBatteryLevel method is invoked. If the fetch is successful, we receive the battery level; if not, a PlatformException is thrown.
Now, we will look into the native side's (Android in this case) code.
In the Kotlin code, we declared the same channel using the same name 'flutter.native/helper'. Then we override the configureFlutterEngine method, where we set a method call handler. The handler listens for the 'getBatteryLevel' method call, executes the getBatteryLevel method, and sends the results back to Flutter.
Remember, the method channel relies on the channel name being identical in both the Dart and native code. This is how cross-platform communication happens in a Flutter app, thanks to Flutter platform channels and MethodChannel.
Here, we take a closer look at the anatomy of a method call handler, a critical component of MethodChannel.
A method call handler is a function that responds to a specific method call coming from the platform side. It receives a MethodCall object with the method's name and any arguments. The handler then processes this information and returns a result or throws an exception.
As seen in the Dart code above, method calls are received through a switch statement that processes different methods based on call.method. If the method corresponds with 'platformMethod', it processes the platform method and returns a result. If a method fails to match any known methods, the handler throws a MissingPluginException() which signifies that no corresponding method exists on the plugin's platform-side.
It's important to understand the logical execution of method calls and how to define and organize the handler function effectively. Proper design of the handler function significantly affects how your Flutter app communicates with platform-specific code.
While Flutter promises an alluring cross-platform framework, being able to write platform-specific code is a boon when leveraging features unique to Android or iOS. In this section, we will detail how to pen platform-specific code using Flutter platform channels.
A few scenarios where you might need to write platform specific code are:
Here's a simple example of sending messages from Dart to Android and iOS:
In the example above, we first ascertain which host platform the Flutter app is running on by calling Platform.isAndroid and Platform.isIOS. After that, we invoke a function on the platform-specific method based on the host platform.
The AndroidMethod and iosMethod are native methods defined in their respective platform-specific code files.
Similarly, developers can exercise this methodology for complex functionalities and platform-specific APIs, accentuating the power of Flutter platform channels.
When utilizing Flutter platform channels, you may occasionally encounter issues or bumps. Handling such errors can be crucial to maintain your Flutter app's performance and reliability. A critical tactic in dealing with errors is to monitor them when calling methods on the channel. This is done using a try-catch block to catch any PlatformException that may occur.
Let's illustrate this with an example:
In this Dart code snippet, we employ a try-catch block to handle possible errors that could arise when we invoke the method MethodName. If a PlatformException is encountered, we print out the error message to our console.
Another error you might encounter is the MissingPluginException. This exception occurs when Flutter cannot find the platform channel you are trying to use. It typically happens when the channel name on the Dart side and the native side doesn't match, or the native side handler for that channel is not set up. Hence, ensure that channel names and handlers are correctly set up on both Dart and native sides.
Always remember, catching errors and exceptions from platform-specific code and handling them correctly is part and parcel of creating a robust and reliable Flutter app.
After an in-depth understanding of various Flutter platform channels and their practical implementations, one question you may come up with is - "Why not directly interface Dart code with Java or Swift?"
Well, while it might seem like a more accessible route at first, direct communication between Dart and native languages like Java or Swift might not always be the ideal choice, especially when considering long-term software maintenance and scalability.
Let's understand why Flutter platform channels gain the upper hand over direct communication.
Direct communication implies writing native code in your Dart files, often using inline strings, and then having Dart interface with this code. This approach could be facilitated using a package like 'ffi'.
While this may seem quicker or more straightforward in the short run, it might have repercussions. The primary issue being, as your project grows, maintaining this intertwined network of native and Dart codebase can become increasingly complex.
On the other hand, Flutter platform channels segregate native code cleanly away from your Dart codebase. This separation of concerns mitigates the complexity of having intertwined code.
A second advantage of using Flutter platform channels over direct communication is its compatibility with the Flutter framework. Flutter inherently supports efficient binary serialization, facilitating high-performance, low-latency communications.
As the goal is to create a responsive user interface, optimizing message passing's performance can be crucial for the success of your Flutter app. And, Flutter platform channels inherently support this through their architecture, a feat direct communication might not achieve as efficiently.
In essence, the Flutter platform channel offers a more scalable, maintainable, and performant approach than direct interfacing with the native code.
Efficient utilization of Flutter platform channels is vital to ensure seamless, error-free communication between Dart and native code. Here, we share insightful best practices one should adhere to while dealing with platform channels:
Ensure consistent channel names across Dart, Android, and iOS code. The channel name is the first point of contact in the communication link. Any discrepancies could lead to confusion and disrupt the smooth flow of data.
It is good practice to use a unique and descriptive channel name to avoid potential conflicts with other plugins.
Error handling is an integral part of any code, and the same goes for working with platform channels.
In the Dart code above, setMethodCallHandler contains a try-catch block that returns a PlatformException with the code "ERROR" when an exception is caught. This way, errors will be handled gracefully without causing your Flutter app to crash.
Remember to avoid long-running operations that can block the platform channels, as it would make your Flutter app unresponsive.
It's always better to handle such tasks in the background thread and communicate the result to your Flutter app through the channels.
Choose the correct type of platform channel based on your requirements. If you need to invoke native functions and expect a result back, use MethodChannel. If you need continuous event-based communication from the host platform, use EventChannel. And for bidirectional communication, go for BasicMessageChannel.
Be cautious with the keyword restrictions of the platform channels. Method names, channel names, and argument keys are strings and should follow the format specified by the host platform (Java or Objective-C/Swift).
By adhering to these best practices, developers can avoid common pitfalls and make the most out of Flutter platform channels.
No doubt, the concept of Flutter platform channels is universal across Flutter apps. Still, understanding its application in various real-world scenarios will consolidate your grasp over the concept. Let's explore a few situations where Flutter platform channels come into play.
In most cases, Flutter developers use platform channels to communicate between Dart and platform-specific native code. It might involve running platform-specific APIs in your Flutter app or invoking native methods not exposed via an existing package.
At times, your Flutter app might require to send or receive complex data like streams or large binary blobs. With the standard message codec, a Flutter platform channel can handle byte buffers, which makes it fit to manage such data exchanges efficiently.
Platform channels also come to rescue when your Flutter app needs to manage errors derived from platform-specific code. You can design your platform channel to communicate such error messages from the native platform to your Dart code and handle them accordingly.
Let's look at an example of error handling in the Dart code:
In this script, if an unrecognized method is triggered from the platform side, the Dart method call handler throws an error with code "unknown_method". This mechanism ensures that any unknown method calls from host platforms can be caught and handled efficiently.
Sometimes, your Flutter app might need to ensure that the user interface remains responsive even while performing resource-intensive tasks. With platform channels supporting asynchronous message passing, it becomes possible to offload such tasks to the native code while keeping the user interface spirited and responsive.
Remember, how effectively you leverage platform channels in your Flutter app often comes down to understanding your app's needs and how different Flutter platform channels can cater to those requirements.
While MethodChannel and its relatives primarily deal with String data, Flutter facilitates handling non-string data within method channels, too. The standard message codec in the Flutter platform channel supports efficient binary serialization of simple JSON-like values, which include not just strings but booleans, lists, maps, and even byte buffers.
By utilizing codecs for serialization, we can easily send and receive non-string data. When data is transmitted over a channel, it gets serialized to a binary form, transmitted, and then deserialized at the receiver's end. This process allows secure and efficient communication of data types over method channels.
Here's an example showcasing how you can send a map data structure using MethodChannel:
In the above Dart code, we are sending a map via the MethodChannel. After sending, we await a response from the receiver's end.
Remember, while MethodChannel does offer a wide array of data types for transmission, you may require more advanced codecs when dealing with complex, custom data structures, domain-specific models, or platform specific data types.
As the Flutter platform evolves, there’s an increasing demand for apps to interact deeply with the host platform, utilizing platform-specific APIs. This often leads to a transition or migration towards using Flutter platform channels.
To answer this, let's address the most significant advantage of using Flutter platform channels. They render direct interaction with platform-specific native code, aiding in using specific APIs and delivering a more native-like feel to the apps. Developers can invoke native methods from Dart, harnessing the power of the underlying platform.
Further, the platform channels bestow greater control over the UI components, leading to user interface enhancements and making your Flutter app more responsive.
Identify the code components that need to communicate with the host platform. These might include UI elements that rely on the platform side or any platform-specific APIs.
Decide whether a MethodChannel, EventChannel, or Basic MessageChannel suits the needs of these components. Remember that MethodChannel is for invoking platform methods from Dart and getting a response. EventChannel is for listening to platform events, while BasicMessageChannel is for sending simple messages back and forth without expecting a direct response.
Initialize the platform channel on both the Dart side and the native side. Be consistent with the channel name.
Set up the method call handler on the Dart side to handle incoming method calls from the native platform. This is required for MethodChannel and can be adapted for BasicMessageChannel too.
Now, your Dart code can call a method on the platform channel. You use the MethodChannel's invokeMethod function for this.
Handle the method call on the native side, perform the necessary operations, and send back a response/result if required.
Test your setup by running specific method calls and check if the call is correctly handled in your native code.
By migrating to Flutter platform channels, you can unlock the full potential of your Flutter app, leading to a richer and more immersive user experience.
To give a fair view of how Flutter platform channels intertwine with real-world applications, let's focus on some fascinating case studies. These stories ought to provide a clearer understanding of the practicability and effectiveness of Flutter platform channels in diverse scenarios.
A renowned e-commerce business wanted to leverage a third-party SDK for payment processing in their Flutter app. However, as the SDK was written in Swift for iOS and Kotlin for Android, they faced a challange: How could the Dart logic communicate with the native code efficiently?
The answer was in Flutter platform channels. They initialized a MethodChannel, ensuring a fluent dialogue between the Dart code and the platform-specific native code.
Through method calls, the Flutter app invoked methods for different tasks, like initiating payment, and returned results like transaction status. They even converted non-string data into JSON and passed it through the MethodChannel where the data got deserialized back into platform-specific data types.
In another use case, a technology solutions firm aimed to build a Flutter application for interacting with a device's specific hardware features not supported by default Flutter libraries.
They employed MethodChannels and wrote platform-specific code in Android and iOS to use sensors unsupported by Flutter. The MethodChannels facilitated communication between Dart and platform channels and fetched real-time sensor data.
By leveraging Flutter platform channels, they created a cohesive app that could seamlessly access and display sensor data in real-time.
In both cases, the companies were able to create enhanced user experiences by communicating with platform-specific APIs and libraries. Flutter platform channels were instrumental in overcoming the challenges faced and achieving the desired results.
While Flutter platform channels provide an avenue for employing platform-specific functionalities in your Flutter app, they can often be misused or misunderstood, especially by novices. Let's discuss some of the most common mistakes developers make when working with platform channels and ways to evade them.
Mismatched channel names are among the most prevalent mistakes. Ensuring consistency in channel names across Dart and your host platform's native code is critical. A discrepancy could lead to a communication breakdown between Dart and native platforms.
Another common pitfall is forgetting that method call handlers run asynchronously. Developers sometimes assume that the handler code will execute immediately after the method call, leading to issues in order of code execution.
Here is an example of such misusage:
The print statement will execute immediately after the invokeMethod call, regardless of whether the async operation has completed. Developers must account for such asynchronous behavior when using invokeMethod.
While working with MethodChannel, it's common to receive unanticipated exceptions thrown when invoking a method.
If not contained within a try-catch block, these exceptions can lead to app crashes. It's always recommended to add appropriate error handling blocks to prevent such occurrences.
Reusing an existing channel could often lead to inconsistent states.
Such instances should be avoided as creating multiple channel objects with the same channel name can lead to inconsistent states and obscure errors.
While Flutter method channels support transfer of simple json-like values, sometimes, you'll need to transfer complex data structures or binary data. Instead of attempting to serialize them manually, use StandardMethodCodec or StandardMessageCodec. They offer built-in support for efficient binary serialization.
By being careful about these common pitfalls, you can leverage platform channels efficiently to boost your Flutter app's performance.
In this blog, we journeyed together through the concept of Flutter platform channels, understanding MethodChannel, EventChannel, and BasicMessageChannel. We also discovered how platform-specific code in Android and iOS can be written using platform channels. We dived deep into the importance of a method call handler in receiving method calls and responding correctly in the channel communication.
Remember, it's not a straight road. You might encounter errors and have to deal with code in languages you're unfamiliar with (maybe Objective C or Kotlin). But persevering through these challenges makes the payoff much greater.
The possibilities with Flutter platform channels are endless, and as we continue to evolve with Flutter, this feature will undoubtedly become even more influential.
// Dart Code
platform.setMethodCallHandler((MethodCall call) async {
switch (call.method) {
case 'MethodName':
return "Hello from Dart!";
default:
throw new PlatformException(
code: "unknown_method",
message: "Unknown method invoked",
details: null,
);
}
});// Swift Code
let eventChannel = FlutterEventChannel(name:"flutter_event_channel", binaryMessenger: controller.binaryMessenger)
// Set the stream handler to receive events
eventChannel.setStreamHandler(ExampleEventStreamHandler())// Dart Code
const msgChannel = const BasicMessageChannel('flutter.msgChannel', const StandardMessageCodec());
// Android Kotlin Code
val msgChannel = BasicMessageChannel(flutterView, "flutter.msgChannel", StandardMessageCodec.INSTANCE)// Dart Code
const platform = const MethodChannel('flutter.native/helper');// Kotlin Code
class MainActivity: FlutterActivity() {
private val CHANNEL = "flutter.native/helper"
override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
call, result ->
if(call.method == "MethodName") {
result.success("Hello from Kotlin!")
} else {
result.notImplemented()
}
}
}
}// Swift Code
import Flutter
import UIKit
class AppDelegate: FlutterAppDelegate {
let CHANNEL_NAME = "flutter.native/helper"
override func application(_ application:UIApplication, didFinishLaunchingWithOptions launchOptions:[UIApplication.LaunchOptionsKey: Any]?) -> Bool {
let controller: FlutterViewController = self.window?.rootViewController as! FlutterViewController
let methodChannel = FlutterMethodChannel(name: CHANNEL_NAME, binaryMessenger: controller as! FlutterBinaryMessenger)
methodChannel.setMethodCallHandler({
(call: FlutterMethodCall, result: FlutterResult) -> Void in
if(call.method == "MethodName") {
result("Hello from Swift")
}
else {
result(FlutterMethodNotImplemented)
}
})
return super.application(application, didFinishLaunchingWithOptions: launchOptions)
}
}// Dart Code
import 'package:flutter/services.dart';
class BatteryLevel {
static const platform = const MethodChannel('flutter.native/helper');
Future<String> getBatteryLevel() async {
String batteryLevel;
try {
final int result = await platform.invokeMethod('getBatteryLevel');
batteryLevel = 'Battery level at $result %.';
} on PlatformException catch (e) {
batteryLevel = "Failed to get battery level: '${e.message}'.";
}
return batteryLevel;
}
}// Kotlin Code
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.embedding.engine.dart.DartExecutor
import io.flutter.plugin.common.MethodChannel
import android.os.BatteryManager
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES
import android.content.ContextWrapper
import android.content.Intent
import android.content.IntentFilter
import android.os.Bundle
class MainActivity: FlutterActivity() {
private val CHANNEL = "flutter.native/helper"
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
super.configureFlutterEngine(flutterEngine)
MethodChannels(flutterEngine.dartExecutor.binaryMessenger).setMethodCallHandler{
call, result ->
if (call.method == "getBatteryLevel") {
val batteryLevel = getBatteryLevel()
if (batteryLevel != -1) {
result.success(batteryLevel)
} else {
result.error(
"UNAVAILABLE",
"Could not fetch battery level.",
null
)
}
} else {
result.notImplemented()
}
}
}
private fun getBatteryLevel(): Int {
return if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
val batteryManager = getSystemService(BATTERY_SERVICE) as BatteryManager
batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
} else {
val intentFilter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
val intent = registerReceiver(null, intentFilter)
intent!!.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) * 100 /
intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
}
}
}// Dart Code
platform.setMethodCallHandler((MethodCall call) async {
switch (call.method) {
case 'platformMethod':
// process platformMethod
return "Some result";
default:
throw MissingPluginException();
}
});// Dart code
if (Platform.isAndroid) {
platformMethodChannel.invokeMethod('androidMethod');
} else if (Platform.isIOS) {
platformMethodChannel.invokeMethod('iosMethod');
}// Platform Specific Android Code
override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
if (call.method == "androidMethod") {
// Android specific implementation
} else {
result.notImplemented()
}
}// Dart Code
try {
String response = await platform.invokeMethod('MethodName');
// do something with the response
} on PlatformException catch (e) {
// handle the exception
print("Failed: '${e.message}'.");
}// Dart Code
const platform = const MethodChannel('com.example/app');
// Android Kotlin Code
val channel = MethodChannel(flutterView, "com.example/app")platform.setMethodCallHandler((MethodCall call) async {
try{
switch(call.method){
case ...
default:
return null;
}
} catch (e){
return new PlatformException(code: "ERROR", message: e.toString(), details: null);
}
});// Android Kotlin Code
override fun onMethodCall(call: MethodCall, result: Result) {
Thread(Runnable {
// long-running operation
...
result.success("Success")
}).start()
}// Dart Code
platform.setMethodCallHandler((MethodCall call) async {
switch (call.method) {
case 'MethodName':
return "Hello from Dart!";
default:
throw PlatformException(
code: "unknown_method",
message: "Unknown method has been invoked",
details: null,
);
}
}
);final methodChannel = MethodChannel('flutter/mapChannel');
void sendMapData() async {
try {
var mapData = {
'key1': 'value1',
'key2': 'value2'
};
String response = await methodChannel.invokeMethod('sendMapData', mapData);
print(response);
} on PlatformException catch (e) {
print("Exception occurred: ${e.message}");
}
}// Dart Code
const platform = const MethodChannel('flutter.native/helper');
// Kotlin Code
val channel = MethodChannel(flutterView, "flutter.native/helper")platform.invokeMethod('MethodName', args);// Dart Code
const platform = const MethodChannel('flutter.wrongname/helper');
// Android Kotlin Code
val channel = MethodChannel(flutterView, "flutter.correctname/helper")// Dart Code
platform.invokeMethod('getDeviceInfo'); // Async method
print('Device information fetched'); // Executes immediately after the previous line// Dart Code
try {
response = await platform.invokeMethod('MethodName');
} on PlatformException catch (e) {
// Handle exception by printing error message
print('An error occurred: ${e.message}');
}// Dart Code
// Defined global channel
const platform = const MethodChannel('flutter.channelname/helper');
// Android Kotlin Code
val channel = MethodChannel(flutterView, "flutter.channelname/helper")
// Later creating another MethodChannel with same name
val anotherChannel = MethodChannel(flutterView, "flutter.channelname/helper")