Flutter Platform Channels: Native Kod Entegrasyonu

import class="code-string">'package:flutter/services.dart';

class BatteryService {
  static const _channel = MethodChannel(class="code-string">'com.example.app/battery');

  Future<int> getBatteryLevel() async {
    try {
      final int level = await _channel.invokeMethod(class="code-string">'getBatteryLevel');
      return level;
    } on PlatformException catch (e) {
      throw Exception(class="code-string">'Pil seviyesi alınamadı: ${e.message}');
    }
  }

  Future<bool> isCharging() async {
    final bool charging = await _channel.invokeMethod(class="code-string">'isCharging');
    return charging;
  }
}

import Flutter
import UIKit

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

    batteryChannel.setMethodCallHandler { (call, result) in
      switch call.method {
      case "getBatteryLevel":
        let device = UIDevice.current
        device.isBatteryMonitoringEnabled = true
        let level = Int(device.batteryLevel * 100)
        if level >= 0 {
          result(level)
        } else {
          result(FlutterError(
            code: "UNAVAILABLE",
            message: "Simülatörde pil seviyesi mevcut değil",
            details: nil
          ))
        }
      case "isCharging":
        let device = UIDevice.current
        device.isBatteryMonitoringEnabled = true
        let state = device.batteryState
        result(state == .charging || state == .full)
      default:
        result(FlutterMethodNotImplemented)
      }
    }

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

import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
import android.os.BatteryManager
import android.content.Context

class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.example.app/battery"

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

        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)
            .setMethodCallHandler { call, result ->
                when (call.method) {
                    "getBatteryLevel" -> {
                        val batteryManager =
                            getSystemService(Context.BATTERY_SERVICE) as BatteryManager
                        val level = batteryManager.getIntProperty(
                            BatteryManager.BATTERY_PROPERTY_CAPACITY
                        )
                        if (level >= 0) {
                            result.success(level)
                        } else {
                            result.error("UNAVAILABLE", "Pil seviyesi alınamadı", null)
                        }
                    }
                    "isCharging" -> {
                        val batteryManager =
                            getSystemService(Context.BATTERY_SERVICE) as BatteryManager
                        val charging = batteryManager.isCharging
                        result.success(charging)
                    }
                    else -> result.notImplemented()
                }
            }
    }
}

class AccelerometerService {
  static const _eventChannel = EventChannel(class="code-string">'com.example.app/accelerometer');

  Stream<AccelerometerReading> get readings {
    return _eventChannel.receiveBroadcastStream().map((event) {
      final data = Map<String, double>.from(event as Map);
      return AccelerometerReading(
        x: data[class="code-string">'x']!,
        y: data[class="code-string">'y']!,
        z: data[class="code-string">'z']!,
      );
    });
  }
}

class AccelerometerReading {
  final double x, y, z;
  const AccelerometerReading({required this.x, required this.y, required this.z});
}

import CoreMotion

class AccelerometerStreamHandler: NSObject, FlutterStreamHandler {
    private let motionManager = CMMotionManager()

    func onListen(withArguments arguments: Any?,
                  eventSink events: @escaping FlutterEventSink) -> FlutterError? {
        motionManager.accelerometerUpdateInterval = 0.1
        motionManager.startAccelerometerUpdates(to: .main) { data, error in
            if let error = error {
                events(FlutterError(
                    code: "SENSOR_ERROR",
                    message: error.localizedDescription,
                    details: nil
                ))
                return
            }
            if let data = data {
                events(["x": data.acceleration.x,
                        "y": data.acceleration.y,
                        "z": data.acceleration.z])
            }
        }
        return nil
    }

    func onCancel(withArguments arguments: Any?) -> FlutterError? {
        motionManager.stopAccelerometerUpdates()
        return nil
    }
}

const messageChannel = BasicMessageChannel<String>(
  class="code-string">'com.example.app/status',
  StringCodec(),
);

class=class="code-string">"code-comment">// Mesaj gönder
await messageChannel.send(class="code-string">'ping');

class=class="code-string">"code-comment">// Nativeclass="code-string">'den mesaj al
messageChannel.setMessageHandler((String? message) async {
  print('Native taraftan gelen: $messageclass="code-string">');
  return 'onaylandı';
});

import class="code-string">'package:pigeon/pigeon.dart';

class DeviceInfo {
  String? model;
  String? osVersion;
  int? batteryLevel;
}

@HostApi()
abstract class DeviceApi {
  DeviceInfo getDeviceInfo();
  bool isFeatureSupported(String featureName);
}

@FlutterApi()
abstract class DeviceEventApi {
  void onBatteryLevelChanged(int level);
}

dart run pigeon --input pigeons/device_api.dart

import class="code-string">'dart:ffi';
import class="code-string">'package:ffi/ffi.dart';

typedef NativeAddFunc = Int32 Function(Int32 a, Int32 b);
typedef DartAddFunc = int Function(int a, int b);

class NativeMath {
  late final DartAddFunc _add;

  NativeMath() {
    final dylib = DynamicLibrary.open(class="code-string">'libnative_math.so');
    _add = dylib.lookupFunction<NativeAddFunc, DartAddFunc>(class="code-string">'add_numbers');
  }

  int add(int a, int b) => _add(a, b);
}

#include <stdint.h>

int32_t add_numbers(int32_t a, int32_t b) {
    return a + b;
}

result(FlutterError(code: "PERMISSION_DENIED",
                    message: "Kamera izni verilmedi",
                    details: ["requiredPermission": "camera"]))

result.error("PERMISSION_DENIED",
             "Kamera izni verilmedi",
             mapOf("requiredPermission" to "camera"))

try {
  await _channel.invokeMethod(class="code-string">'startCamera');
} on PlatformException catch (e) {
  if (e.code == class="code-string">'PERMISSION_DENIED') {
    class=class="code-string">"code-comment">// İzin isteme dialogunu göster
  } else {
    debugPrint(class="code-string">'Platform hatası: ${e.code} - ${e.message}');
  }
}

"code-comment">// Yanlış: Ana thread'i bloke eder
call.method == "processImage" -> {
    val result = heavyImageProcessing() "code-comment">// Arayüzü dondurur
    result.success(result)
}

"code-comment">// Doğru: Arka plan thread'ine yönlendir
call.method == "processImage" -> {
    thread {
        val processed = heavyImageProcessing()
        Handler(Looper.getMainLooper()).post {
            result.success(processed)
        }
    }
}

case "processImage":
    DispatchQueue.global(qos: .userInitiated).async {
        let processed = self.heavyImageProcessing()
        DispatchQueue.main.async {
            result(processed)
        }
    }