Bölüm 9 — Konu 40: Platform Channels

Bölüm 9'a ("Platform & Native") hoş geldin. Şimdiye kadar öğrendiğimiz her şey Dart/Flutter dünyasının içindeydi. Ama bazen, cihazın pil seviyesini okumak, native bir SDK'yı (örneğin bir ödeme kütüphanesini) kullanmak, ya da Flutter'ın henüz sarmalamadığı bir platform özelliğine erişmek gerekir. Bu derste, Dart kodunun Android'in Kotlin/Java'sıyla ya da iOS'un Swift/Objective-C'siyle nasıl "konuştuğunu" öğreneceğiz.

#Flutter'ın Native ile İlişkisi — Kısa Hatırlatma

Bölüm 1 Konu 1'de öğrendiğimiz mimariyi hatırla: Flutter, kendi widget'larını Skia/Impeller ile doğrudan ekrana çizer — yani native UI bileşenlerini kullanmaz (bir Android Button'ı ya da iOS UIButton'ı değildir, Flutter'ın kendi çizdiği bir dikdörtgendir). Ama Flutter uygulaması, sonuçta gerçek bir Android/iOS uygulamasının içinde çalışır — ve bazen, o native ortamın kendi API'lerine (kamera, konum, dosya sistemi, üçüncü parti SDK'lar) erişmek gerekir. Platform Channel, bu ihtiyacı karşılayan köprüdür.

#Temel Fikir — İki Taraf, Bir "Kanal İsmi"

┌─────────────────────┐         Platform Channel          ┌──────────────────────┐
│   Dart tarafı        │  ── 'com.ornek.app/pil' ──────►  │  Native taraf          │
│  (MethodChannel)     │  ◄── sonuç/hata ────────────────  │ (Kotlin veya Swift)    │
└─────────────────────┘                                    └──────────────────────┘

İki taraf da aynı string ismindeki bir kanalı kullanarak birbirini bulur — tıpkı Bölüm 7 Konu 30'da go_router'da bir rota ismiyle (path) eşleşme yapmamız gibi, burada da kanal ismi ('com.ornek.app/pil' gibi) eşleşme anahtarı.

#MethodChannel — Dart Tarafı

import 'package:flutter/services.dart';

class PilServisi {
  static const _kanal = MethodChannel('com.ornek.app/pil');

  static Future<int> pilSeviyesiniAl() async {
    try {
      final int seviye = await _kanal.invokeMethod('pilSeviyesiAl');
      return seviye;
    } on PlatformException catch (hata) {
      print('Pil seviyesi alınamadı: ${hata.message}');
      return -1;
    }
  }
}

Parça parça inceleyelim:

MethodChannel('com.ornek.app/pil') — kanalın adı, genelde paket.adi/ozellik formatında (çakışmayı önlemek için). Bu isim, native tarafta birebir aynı yazılmalı.

await _kanal.invokeMethod('pilSeviyesiAl') — Bölüm 5 Konu 18'de öğrendiğimiz async/await'i hatırla; native tarafa bir çağrı yapmak asenkron bir işlemdir (native kod çalışıp bir sonuç dönene kadar Dart bekler) — bu yüzden Future<int> döner.

on PlatformException catch (hata) — Dart Bölüm 8'de öğrendiğimiz özel exception yakalama; native taraftan bir hata gelirse (kod bulunamadı, native tarafta bir exception fırlatıldı vb.), bu PlatformException olarak Dart'a taşınır.

#Native Taraf — Android (Kotlin)

// android/app/src/main/kotlin/.../MainActivity.kt
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity: FlutterActivity() {
    private val KANAL = "com.ornek.app/pil"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KANAL).setMethodCallHandler { call, result ->
            if (call.method == "pilSeviyesiAl") {
                val seviye = pilSeviyesiniGetir()
                if (seviye != -1) {
                    result.success(seviye)
                } else {
                    result.error("KULLANILAMIYOR", "Pil seviyesi alınamadı", null)
                }
            } else {
                result.notImplemented()
            }
        }
    }

    private fun pilSeviyesiniGetir(): Int {
        // gerçek Android API çağrısı burada olurdu
        return 85
    }
}

Kotlin bilmene gerek yok (bu tutorial'ın kapsamı dışında) — ama yapıyı tanıman önemli: call.method, Dart tarafındaki invokeMethod('pilSeviyesiAl') çağrısındaki string ile eşleşiyor (Bölüm 3 Konu 12'de öğrendiğimiz switch/if mantığına benzer bir yönlendirme). result.success(seviye), Dart tarafındaki await'in döndüreceği değeri belirliyor; result.error(...), Dart tarafında PlatformException olarak yakalanacak hatayı oluşturuyor.

#Native Taraf — iOS (Swift)

// ios/Runner/AppDelegate.swift
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 kanal = FlutterMethodChannel(name: "com.ornek.app/pil", binaryMessenger: controller.binaryMessenger)

    kanal.setMethodCallHandler { (call, result) in
      if call.method == "pilSeviyesiAl" {
        result(85) // gerçek iOS API çağrısı burada olurdu
      } else {
        result(FlutterMethodNotImplemented)
      }
    }

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

Kritik gözlem: Aynı kanal ismi ("com.ornek.app/pil") ve aynı metod ismi ("pilSeviyesiAl"), hem Android hem iOS tarafında birebir aynı yazılmalı — Dart tarafındaki MethodChannel kodu, hangi platformda çalıştığını bilmez, sadece kanal ismiyle "doğru tarafı" bulur. Bu, Bölüm 7'de öğrendiğimiz interface/implementasyon ayrımına (bir Repository arayüzünün farklı implementasyonları gibi) kavramsal olarak benzer — Dart tarafı, hangi native implementasyonun çalıştığından habersiz, sadece sözleşmeye (kanal ismi + metod isimleri) güveniyor.

#EventChannel — Sürekli Veri Akışı İçin

MethodChannel, tek seferlik bir istek-cevap içindir (bir soru sor, bir cevap al). Native taraftan sürekli veri akması gerekiyorsa (örneğin bir sensörden gelen sürekli okuma), EventChannel kullanılır — Bölüm 5 Konu 19'da öğrendiğimiz Stream kavramının native köprü karşılığıdır:

class SensorServisi {
  static const _kanal = EventChannel('com.ornek.app/ivmeolcer');

  static Stream<double> ivmeVerisiAl() {
    return _kanal.receiveBroadcastStream().map((veri) => veri as double);
  }
}

StreamBuilder<double>( // Bölüm 5 Konu 19'u hatırla
  stream: SensorServisi.ivmeVerisiAl(),
  builder: (context, snapshot) {
    if (!snapshot.hasData) return const CircularProgressIndicator();
    return Text('İvme: ${snapshot.data}');
  },
)

Native taraf, EventChannel'a bir EventSink üzerinden sürekli değer gönderir (sink.success(deger)), Dart tarafında bu, tanıdık bir Stream<double>'a dönüşür — Bölüm 5 Konu 19'daki StreamBuilder ile aynı şekilde tüketilir.

#Pratik Gerçek — Genelde Elle Yazmana Gerek Kalmaz

Önemli bir uyarı: Gerçek geliştirmede, çoğu zaman platform channel'ı elle yazman gerekmez — camera, geolocator, battery_plus, local_auth gibi hazır paketler, bu native köprüyü senin için zaten kurmuş durumda, sen sadece Dart tarafındaki basit API'yi çağırırsın (Bölüm 9 Konu 42'de kamera/konum paketlerini göreceğiz). Platform channel'ı elle yazmak, genelde şu durumlarda gerekir:

• Çok niş bir native SDK'ya erişim gerekiyor ve hazır bir Flutter paketi yok.
• Kendi bir Flutter paketini (plugin) yazıp yayınlıyorsun (Bölüm 12 Konu 58'de göreceğiz).
• Var olan bir native uygulamaya Flutter'ı entegre ediyorsun (add-to-app senaryosu).

#Pigeon — Daha Tip Güvenli Bir Alternatif

Yukarıdaki MethodChannel kodunda dikkat ettiysen, call.method bir string, dönüş değeri dinamik (Any/Object) — yazım hatası riski var, derleme zamanında yakalanmaz. Flutter ekibinin resmi olarak sunduğu pigeon paketi, bir arayüz tanımından (Dart'ta yazılan bir "şema" dosyasından) hem Dart hem Kotlin hem Swift tarafı için tip güvenli kod üretir (Dart Bölüm 13'te öğrendiğimiz build_runner code generation mantığına benzer). Büyük/uzun soluklu platform channel ihtiyaçlarında pigeon, elle MethodChannel yazmaktan daha sağlam bir tercihtir — bu tutorial kapsamında sadece var olduğunu bilmen yeterli.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Platform Channel, Dart kodu ile native (Kotlin/Swift) kod arasında, ortak bir kanal ismi üzerinden çalışan bir köprüdür.
• MethodChannel, tek seferlik istek-cevap iletişimi için kullanılır; invokeMethod() asenkron çalışır (Future döner), native taraftaki hatalar PlatformException olarak yakalanır.
• Native tarafta (Android: Kotlin, iOS: Swift), setMethodCallHandler ile gelen çağrılar call.method string'ine göre yönlendirilir, result.success()/result.error() ile cevap verilir.
• EventChannel, native taraftan sürekli veri akışı gerektiğinde kullanılır — Dart tarafında tanıdık bir Stream olarak tüketilir.
• Pratikte, çoğu native ihtiyaç zaten hazır paketlerle (camera, geolocator vb.) karşılanır — elle platform channel yazmak niş durumlar içindir.
• pigeon, elle yazılan MethodChannel koduna göre daha tip güvenli, code-generation tabanlı bir alternatiftir.

#📝 Ödevler

• [ ] Basit bir MethodChannel kur (Android veya iOS tarafında, hangisini geliştiriyorsan), sabit bir değer (örn. 42) döndüren bir native metod yaz ve Dart tarafından çağır.
• [ ] Native tarafta bilerek bir result.error(...) (Android) / hata durumu (iOS) tetikle, Dart tarafında PlatformException'ı yakalayıp ekranda göster.
• [ ] Kendi cümlelerinle, "MethodChannel ile EventChannel arasındaki farkın, Dart Bölüm 5'te öğrendiğimiz Future ile Stream arasındaki farka nasıl karşılık geldiğini" açıkla.
• [ ] battery_plus gibi hazır bir paketin kaynak koduna (pub.dev üzerinden GitHub'a) göz at, kendi native tarafında MethodChannel kullanıp kullanmadığını doğrula.

Sıradaki konu: Bölüm 9 — Konu 41: Permission Yönetimi (permission_handler)