Bölüm 5 — Konu 19: `Stream`, `StreamBuilder`

Bir önceki derste FutureBuilder'ı ("bir kerelik" asenkron veri için) öğrendik. Bu derste, Dart Bölüm 10'da öğrendiğimiz Stream ("zamanla, tekrar tekrar gelen veri") kavramının Flutter karşılığını işleyeceğiz.

#StreamBuilder — FutureBuilder'ın Kuzeni

StreamBuilder<int>(
  stream: sayacStream(),
  builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
    if (snapshot.connectionState == ConnectionState.waiting) {
      return CircularProgressIndicator();
    }
    if (snapshot.hasError) {
      return Text('Hata: ${snapshot.error}');
    }
    return Text('Değer: ${snapshot.data}');
  },
)

Fark hemen görülüyor: StreamBuilder, future: yerine stream: parametresi alıyor — ama builder fonksiyonunun imzası birebir aynı (AsyncSnapshot<T> kullanıyor, Bölüm 5 Konu 18'i hatırla). Bu, Flutter'ın API tasarımında tutarlılığı ne kadar önemsediğini gösteriyor — bir kere FutureBuilder'ı öğrendiğinde, StreamBuilder'ı öğrenmek neredeyse ücretsiz oluyor.

#Temel Fark: builder, Kaç Kere Çağrılır?

Dart Bölüm 10 Konu 47'de Stream'in zamanla birden fazla değer ürettiğini öğrenmiştik. StreamBuilder'ın builder fonksiyonu, bu yüzden her yeni veri geldiğinde tekrar çağrılır:

Stream<int> sayacStream() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

Bu stream'i StreamBuilder ile dinlediğinde, ekranda sırasıyla 1, 2, 3, 4, 5 görürsün — her yield gerçekleştiğinde, StreamBuilder otomatik olarak widget'ı yeniden çizer (Bölüm 2 Konu 6'da öğrendiğimiz setState()'e benzer bir mekanizmayı, framework senin için otomatik olarak yönetiyor).

#Neden Bu Kadar Değerli? — setState() ile Karşılaştırma

StreamBuilder olmadan, aynı işi yapmak isteseydin:

// ❌ Elle yönetim — çok daha karmaşık
class SayacWidget extends StatefulWidget {
  @override
  State<SayacWidget> createState() => _SayacWidgetState();
}

class _SayacWidgetState extends State<SayacWidget> {
  int? _deger;
  late StreamSubscription _subscription;

  @override
  void initState() {
    super.initState();
    _subscription = sayacStream().listen((veri) {
      setState(() {
        _deger = veri;
      });
    });
  }

  @override
  void dispose() {
    _subscription.cancel(); // Bölüm 5 Konu 20'de dispose'u derinlemesine göreceğiz
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Text('Değer: ${_deger ?? "Bekleniyor"}');
  }
}

Bu, çalışır ama çok daha fazla kod ve elle yönetilmesi gereken kaynaklar (_subscription.cancel()'ı unutursan, Dart Bölüm 10'da öğrendiğimiz stream kaynak sızıntısı riski) içeriyor. StreamBuilder, bunların hepsini otomatik olarak yapar — widget ekrandan kaldırıldığında, aboneliği kendisi iptal eder.

#Gerçek Dünya Senaryosu — Canlı Sayaç

class CanliSayac extends StatelessWidget {
  const CanliSayac({super.key});

  Stream<int> _sayacStream() async* {
    int sayi = 0;
    while (true) {
      await Future.delayed(Duration(seconds: 1));
      yield sayi++;
    }
  }

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<int>(
      stream: _sayacStream(),
      initialData: 0, // stream'den ilk veri gelene kadar gösterilecek değer
      builder: (context, snapshot) {
        return Text(
          '${snapshot.data}',
          style: TextStyle(fontSize: 48),
        );
      },
    );
  }
}

initialData parametresi — Dart Bölüm 5'te öğrendiğimiz varsayılan parametre kavramına benzer bir mantıkla çalışır: stream henüz hiç veri üretmemişse (ilk yield'den önce), snapshot.data yerine bu başlangıç değeri kullanılır. Bu, FutureBuilder'da olmayan, StreamBuilder'a özgü kullanışlı bir parametredir — çünkü stream'in "hiç veri üretmeden bekleme" süresi genelde daha belirsiz olabilir.

#Stream Aynı Future'daki Gibi Tuzağa Dikkat

Bölüm 5 Konu 18'de öğrendiğimiz kritik tuzağı hatırla — stream: parametresine build() içinde doğrudan bir fonksiyon çağrısı vermek, burada da aynı sorunu yaratır:

// ❌ TEHLİKELİ — her rebuild'de YENİ bir stream başlatılır
StreamBuilder<int>(
  stream: _sayacStream(), // her build() çağrısında yeni bir stream!
  builder: (context, snapshot) => Text('${snapshot.data}'),
)

Doğru çözüm, aynı kalıp:

class CanliSayacDogru extends StatefulWidget {
  @override
  State<CanliSayacDogru> createState() => _CanliSayacDogruState();
}

class _CanliSayacDogruState extends State<CanliSayacDogru> {
  late final Stream<int> _stream; // Bölüm 5 Konu 18'deki AYNI kalıp

  @override
  void initState() {
    super.initState();
    _stream = _sayacStream(); // sadece bir kere oluşturulur
  }

  Stream<int> _sayacStream() async* {
    int sayi = 0;
    while (true) {
      await Future.delayed(Duration(seconds: 1));
      yield sayi++;
    }
  }

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<int>(
      stream: _stream,
      builder: (context, snapshot) => Text('${snapshot.data ?? 0}'),
    );
  }
}

#Broadcast Stream ile Kullanım — Dart Bölüm 10'u Hatırlama

Dart Bölüm 10 Konu 48'de öğrendiğimiz broadcast stream'i hatırlarsan — eğer aynı stream'i birden fazla StreamBuilder (farklı widget'larda) dinleyecekse, o stream'in broadcast olması gerekir:

class BildirimServisi {
  final StreamController<String> _controller = StreamController<String>.broadcast();
  Stream<String> get bildirimler => _controller.stream;

  void bildirimGonder(String mesaj) {
    _controller.add(mesaj);
  }
}

Bu, gerçek uygulamalarda birden fazla ekranın aynı veri kaynağını (örneğin bir "okunmamış mesaj sayısı" göstergesi, hem ana ekranda hem ayarlar ekranında) dinlemesi gerektiğinde kullanılan bir kalıptır — Bölüm 6'da state management konusuna geldiğimizde, bu kalıbın daha gelişmiş versiyonlarını (Provider, Riverpod gibi araçlarla) göreceğiz.

#FutureBuilder vs StreamBuilder — Ne Zaman Hangisi?

#🎯 Bu Dersten Çıkarılması Gerekenler

• StreamBuilder, FutureBuilder ile aynı AsyncSnapshot<T> API'sini kullanır, ama builder, stream her yeni veri ürettiğinde tekrar çağrılır.
• StreamBuilder, elle listen()/setState()/cancel() yönetiminin yerine geçer — abonelik yönetimini otomatik yapar.
• initialData, stream ilk veriyi üretene kadar gösterilecek varsayılan değeri belirtir.
• stream: parametresine build() içinde doğrudan fonksiyon çağrısı vermek, FutureBuilder'daki gibi bir tuzaktır — initState() + late final ile çözülür.
• Birden fazla widget aynı stream'i dinleyecekse, stream'in broadcast olması gerekir (Dart Bölüm 10'u hatırla).

#📝 Ödevler

• [ ] Stream.periodic veya async*/yield ile her saniye artan bir sayaç gösteren StreamBuilder örneği yaz.
• [ ] initialData kullanarak, stream ilk veriyi üretmeden önce gösterilecek bir başlangıç değeri belirle.
• [ ] Bilerek stream: parametresine doğrudan fonksiyon çağrısı vererek tuzağa düş, sonra initState() + late final ile düzelt.
• [ ] Broadcast bir StreamController oluştur, aynı stream'i iki farklı StreamBuilder widget'ında dinle.
• [ ] Kendi cümlelerinle, "FutureBuilder ile StreamBuilder'ı ne zaman kullanmalıyım" sorusunu, Dart Bölüm 10'da öğrendiğin Future/Stream farkına dayanarak açıkla.

Sıradaki konu: Bölüm 5 — Konu 20: HTTP İstekleri (http / dio Paketleri)