Battery Status Plugin #

A Flutter plugin example demonstrating platform channel communication to access native device features.

What This Example Demonstrates #

This plugin showcases:

• Platform channel setup for iOS, Android, Web, macOS, Windows, and Linux
• Method channel communication between Dart and native code
• Platform-specific implementations
• Plugin architecture with platform interface pattern
• Example app demonstrating plugin usage

Plugin Architecture #

Key Components #

lib/
├── battery_status_plugin.dart              # Public API
├── battery_status_plugin_platform_interface.dart  # Platform interface
└── battery_status_plugin_method_channel.dart      # Method channel implementation

platform directories/
├── android/                                # Android (Kotlin) implementation
├── ios/                                    # iOS (Swift) implementation
├── web/                                    # Web (JavaScript) implementation
├── macos/                                  # macOS (Swift) implementation
├── windows/                                # Windows (C++) implementation
└── linux/                                  # Linux (C++) implementation

example/                                    # Example app demonstrating usage

Platform Interface Pattern #

The plugin uses a three-layer architecture:

1. Public API (battery_status_plugin.dart) - What users import
2. Platform Interface (platform_interface.dart) - Abstract contract
3. Method Channel (method_channel.dart) - Actual implementation

This pattern allows:

• Testing without platform code
• Easy platform implementation replacement
• Clear separation of concerns

How Platform Channels Work #

Dart Side #

class BatteryStatusPlugin {
  Future<String?> getPlatformVersion() {
    return BatteryStatusPluginPlatform.instance.getPlatformVersion();
  }
}

Native Side (Example: Android) #

class BatteryStatusPlugin: FlutterPlugin, MethodCallHandler {
  override fun onMethodCall(call: MethodCall, result: Result) {
    if (call.method == "getPlatformVersion") {
      result.success("Android ${android.os.Build.VERSION.RELEASE}")
    }
  }
}

Communication flow:

Dart Code → Method Channel → Platform Code → Native APIs
                ↓
          Result/Error
                ↓
            Dart Code

Installation #

dependencies:
  battery_status_plugin: ^1.0.0

Usage #

import 'package:battery_status_plugin/battery_status_plugin.dart';

void main() async {
  final plugin = BatteryStatusPlugin();

  try {
    final version = await plugin.getPlatformVersion();
    print('Platform version: $version');
  } catch (e) {
    print('Error: $e');
  }
}

Platform-Specific Code Locations #

Android (Kotlin) #

android/src/main/kotlin/com/example/battery_status_plugin/BatteryStatusPlugin.kt

iOS (Swift) #

ios/Classes/BatteryStatusPlugin.swift

Web (JavaScript) #

lib/battery_status_plugin_web.dart

macOS (Swift) #

macos/Classes/BatteryStatusPlugin.swift

Windows (C++) #

windows/battery_status_plugin.cpp

Linux (C++) #

linux/battery_status_plugin.cc

Adding New Methods #

To add a new method to the plugin:

1. Update Dart interface:

// lib/battery_status_plugin_platform_interface.dart
Future<int?> getBatteryLevel() {
  throw UnimplementedError('getBatteryLevel() not implemented.');
}

2. Update method channel implementation:

// lib/battery_status_plugin_method_channel.dart
@override
Future<int?> getBatteryLevel() async {
  return await methodChannel.invokeMethod<int>('getBatteryLevel');
}

3. Implement in native code (example for Android):

override fun onMethodCall(call: MethodCall, result: Result) {
  when (call.method) {
    "getBatteryLevel" -> {
      val level = // get battery level from Android APIs
      result.success(level)
    }
  }
}

Testing #

The plugin includes:

• Unit tests for Dart code
• Mock platform implementations for testing
• Example app for manual testing

Run tests:

flutter test

Example App #

The example/ directory contains a complete Flutter app demonstrating the plugin usage. Run it:

cd example
flutter run

Common Plugin Patterns #

Async Results #

Most plugin methods return Future<T> because native operations are asynchronous.

Error Handling #

Use try-catch to handle platform errors:

try {
  final result = await plugin.someMethod();
} on PlatformException catch (e) {
  print('Platform error: ${e.message}');
}

Type Safety #

Method channel supports these types:

• null
• bool
• int
• double
• String
• List
• Map

Development Tips #

Hot Reload Limitations #

Changes to native code require app restart, not just hot reload.

Platform-Specific Debugging #

• Android: Use Android Studio with Logcat
• iOS: Use Xcode with Console
• Desktop: Use platform-specific debuggers

Code Generation #

Method channel boilerplate can be generated using Pigeon for type-safe communication.

Learning More #

• Writing custom platform-specific code
• Developing packages and plugins
• Federated plugins

License #

MIT License - see LICENSE file for details.