Platform Channels and Native Integration

import 'package:flutter/services.dart';

class BatteryService {
  // Namespace the channel name to avoid collisions with plugins
  static const _channel = MethodChannel('dev.flutterlearn/battery');

  Future<int> getBatteryLevel() async {
    try {
      final level = await _channel.invokeMethod<int>('getBatteryLevel');
      if (level == null) throw const BatteryException('No level returned');
      return level;
    } on PlatformException catch (e) {
      throw BatteryException(e.message ?? 'Platform error: ${e.code}');
    } on MissingPluginException {
      // The platform has no implementation — e.g. running on web
      throw const BatteryException('Not supported on this platform');
    }
  }

  Future<void> setLowPowerWarning({required int threshold}) {
    return _channel.invokeMethod<void>('setThreshold', {
      'threshold': threshold,
      'enabled': true,
    });
  }
}

class MainActivity : FlutterActivity() {
    private val channelName = "dev.flutterlearn/battery"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)

        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, channelName)
            .setMethodCallHandler { call, result ->
                when (call.method) {
                    "getBatteryLevel" -> {
                        val level = getBatteryLevel()
                        if (level != -1) {
                            result.success(level)
                        } else {
                            result.error("UNAVAILABLE", "Battery level unavailable", null)
                        }
                    }
                    "setThreshold" -> {
                        val threshold = call.argument<Int>("threshold") ?: 20
                        saveThreshold(threshold)
                        result.success(null)
                    }
                    else -> result.notImplemented()
                }
            }
    }

    private fun getBatteryLevel(): Int {
        val bm = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
        return bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
    }
}

@main
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let controller = window?.rootViewController as! FlutterViewController
    let channel = FlutterMethodChannel(
      name: "dev.flutterlearn/battery",
      binaryMessenger: controller.binaryMessenger
    )

    channel.setMethodCallHandler { call, result in
      switch call.method {
      case "getBatteryLevel":
        UIDevice.current.isBatteryMonitoringEnabled = true
        let level = UIDevice.current.batteryLevel
        if level < 0 {
          result(FlutterError(code: "UNAVAILABLE",
                              message: "Battery level unavailable",
                              details: nil))
        } else {
          result(Int(level * 100))
        }
      default:
        result(FlutterMethodNotImplemented)
      }
    }

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

class ConnectivityService {
  static const _events = EventChannel('dev.flutterlearn/connectivity');

  Stream<bool> get onConnectivityChanged => _events
      .receiveBroadcastStream()
      .map((event) => event as bool)
      .handleError((Object error) {
        debugPrint('Connectivity stream error: $error');
      });
}

// In the UI
StreamBuilder<bool>(
  stream: connectivity.onConnectivityChanged,
  builder: (context, snapshot) {
    final online = snapshot.data ?? true;
    return online ? const SizedBox.shrink() : const OfflineBanner();
  },
)

EventChannel(messenger, "dev.flutterlearn/connectivity").setStreamHandler(
    object : EventChannel.StreamHandler {
        private var callback: ConnectivityManager.NetworkCallback? = null

        override fun onListen(arguments: Any?, events: EventChannel.EventSink) {
            callback = object : ConnectivityManager.NetworkCallback() {
                override fun onAvailable(network: Network) = events.success(true)
                override fun onLost(network: Network) = events.success(false)
            }
            connectivityManager.registerDefaultNetworkCallback(callback!!)
        }

        // Called when Dart cancels the subscription — clean up or leak
        override fun onCancel(arguments: Any?) {
            callback?.let { connectivityManager.unregisterNetworkCallback(it) }
            callback = null
        }
    }
)

import 'package:pigeon/pigeon.dart';

class BatteryInfo {
  BatteryInfo({required this.level, required this.isCharging});
  final int level;
  final bool isCharging;
}

@HostApi()   // Dart calls native
abstract class BatteryApi {
  BatteryInfo getBatteryInfo();
  void setThreshold(int threshold);
}

@FlutterApi()  // native calls Dart
abstract class BatteryEvents {
  void onLowBattery(int level);
}

dart run pigeon --input pigeons/battery_api.dart

import 'dart:ffi';
import 'dart:io';
import 'package:ffi/ffi.dart';

// C: int32_t sum_array(const int32_t* values, int32_t length);
typedef _SumArrayC = Int32 Function(Pointer<Int32>, Int32);
typedef _SumArrayDart = int Function(Pointer<Int32>, int);

final DynamicLibrary _lib = Platform.isAndroid
    ? DynamicLibrary.open('libnative_math.so')
    : DynamicLibrary.process();

final _sumArray = _lib.lookupFunction<_SumArrayC, _SumArrayDart>('sum_array');

int sumArray(List<int> values) {
  final pointer = calloc<Int32>(values.length);
  try {
    for (var i = 0; i < values.length; i++) {
      pointer[i] = values[i];
    }
    return _sumArray(pointer, values.length);
  } finally {
    calloc.free(pointer);   // manual memory management — no GC here
  }
}

flutter create --template=plugin \
  --platforms=android,ios \
  --org dev.flutterlearn \
  flutter_battery_plus