Flutter Mobile Development · Ders

Durum İçin Riverpod

Güçlü ve test edilebilir bir durum yönetimi kitaplığı olan Riverpod'u keşfedin ve karmaşık uygulamalarda diğer çözümlere göre avantajlarını öğrenin.

Durum İçin Riverpod, CoddyKit'te ücretsiz bir Flutter Mobile Development dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Flutter Mobile Development öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Flutter Mobile Development kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Welcome to Riverpod!

Riverpod is a popular state management library for Flutter that aims to be simple, robust, and testable. It's a reimagined version of the Provider package, designed to address some of its limitations.

Think of Riverpod as a powerful toolkit for managing all the data in your app, from user settings to fetched data, in a safe and predictable way.

Riverpod's Core Strengths

Riverpod offers several key advantages:

Compile-time Safety: Catches errors early, before your app even runs.
Testability: Makes it easy to test your business logic in isolation.
Auto-Dispose: Providers can automatically clean up resources when no longer needed.
No Widget Tree Dependency: Providers don't rely on the widget tree, making them more flexible.

It helps you write cleaner, more maintainable code.

Setting Up Your App

To use Riverpod, first add the flutter_riverpod package to your pubspec.yaml. Then, wrap your entire application with a ProviderScope widget. This widget stores the state of all your providers.

Here's how to set it up:

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

void main() {
  runApp(
    // Wrap your app in a ProviderScope
    ProviderScope(
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Text('Hello Riverpod'),
    );
  }
}

Introducing Providers

Providers are the core building blocks of Riverpod. They hold a piece of state and allow you to access it from anywhere in your app.

The simplest provider is a Provider, which holds an immutable value. You define it globally, making it accessible throughout your application.

import 'package:flutter_riverpod/flutter_riverpod.dart';

// A simple Provider that holds an immutable string.
final greetingProvider = Provider<String>((ref) {
  return 'Hello from Riverpod!';
});

// You can also provide numbers, objects, etc.
final counterProvider = Provider<int>((ref) => 0);

Consuming Providers with `ConsumerWidget`

To read a provider's value in your UI, you use a ConsumerWidget. This widget gives you access to a WidgetRef (often named ref), which lets you 'watch' or 'read' providers.

ref.watch() makes your widget rebuild when the provider's value changes.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

final greetingProvider = Provider<String>((ref) {
  return 'Hello Riverpod User!';
});

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final greeting = ref.watch(greetingProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Riverpod App')),
            body: Center(child: Text(greeting)),
          );
        },
      ),
    );
  }
}

Mutable State with `StateProvider`

When you need to change a piece of state directly, use a StateProvider. It exposes a StateController, which has a state property you can modify.

This is perfect for simple UI states like a toggle or a counter.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// A StateProvider for a simple counter.
final counterProvider = StateProvider<int>((ref) => 0);

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final count = ref.watch(counterProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Counter App')),
            body: Center(
              child: Text(
                'Count: $count',
                style: TextStyle(fontSize: 24),
              ),
            ),
            floatingActionButton: FloatingActionButton(
              onPressed: () => ref.read(counterProvider.notifier).state++,
              child: Icon(Icons.add),
            ),
          );
        },
      ),
    );
  }
}

`StateNotifierProvider` for Logic

For more complex state that involves business logic (e.g., fetching data, managing lists), you'll use a StateNotifier with StateNotifierProvider.

StateNotifier is a class you extend, and it holds your state. The provider then exposes an instance of your notifier.

import 'package:flutter_riverpod/flutter_riverpod.dart';

// 1. Define your state class (immutable recommended)
class Todo { 
  final String id; 
  final String description; 
  final bool completed; 
  Todo(this.id, this.description, this.completed); 
}

// 2. Create a StateNotifier to manage the state
class TodosNotifier extends StateNotifier<List<Todo>> {
  TodosNotifier() : super([]); // Initial state is an empty list

  void addTodo(String description) {
    state = [...state, Todo(DateTime.now().toString(), description, false)];
  }

  void toggle(String id) {
    state = [ 
      for (final todo in state) 
        if (todo.id == id) 
          Todo(todo.id, todo.description, !todo.completed) 
        else 
          todo, 
    ];
  }
}

// 3. Create the StateNotifierProvider
final todosProvider = StateNotifierProvider<TodosNotifier, List<Todo>>((ref) {
  return TodosNotifier();
});

Async Data with `FutureProvider`

Riverpod makes handling asynchronous data (like network requests) a breeze with FutureProvider and StreamProvider.

A FutureProvider exposes an AsyncValue, which gracefully handles loading, error, and data states in your UI.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// A FutureProvider that simulates fetching data.
final userProvider = FutureProvider<String>((ref) async {
  await Future.delayed(Duration(seconds: 2)); // Simulate network delay
  return 'John Doe';
});

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final userAsyncValue = ref.watch(userProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Async Data')),
            body: Center(
              child: userAsyncValue.when(
                loading: () => CircularProgressIndicator(),
                error: (err, stack) => Text('Error: $err'),
                data: (user) => Text('User: $user', style: TextStyle(fontSize: 24)),
              ),
            ),
          );
        },
      ),
    );
  }
}

`ref.read` vs `ref.watch`

When interacting with providers, you'll primarily use two methods on the ref object:

ref.watch(provider): Listens to changes in a provider. If the provider's state changes, the widget or provider watching it will rebuild/re-execute. Use this in build methods.
ref.read(provider): Reads a provider's current value once, without listening for future changes. Ideal for one-off actions, like button presses or initial setup.

Avoid ref.read in build methods unless you specifically don't want rebuilds.

Riverpod Provider Types

Which Riverpod provider types are best suited for managing a simple counter (a single integer that can be incremented/decremented) and for handling complex business logic with multiple actions (e.g., adding/removing items from a to-do list)?

Riverpod Recap

Great job! You've explored Riverpod, a powerful and modern state management solution for Flutter.

We learned about ProviderScope for app setup.
We used Provider for immutable data and StateProvider for simple mutable state.
For complex logic, StateNotifierProvider with StateNotifier is key.
FutureProvider helps manage async data gracefully.
Remember ref.watch for listening and ref.read for one-time access.

Riverpod's compile-time safety and testability make it an excellent choice for robust Flutter applications!

Sıkça Sorulan Sorular

“Durum İçin Riverpod” dersi ücretsiz mi?

Evet — “Durum İçin Riverpod” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Flutter Mobile Development kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Flutter Mobile Development kursu toplamda 4 dersten oluşur.

“Durum İçin Riverpod” dersinde ne öğreneceğim?

Güçlü ve test edilebilir bir durum yönetimi kitaplığı olan Riverpod'u keşfedin ve karmaşık uygulamalarda diğer çözümlere göre avantajlarını öğrenin. Flutter Mobile Development ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Flutter Mobile Development öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Flutter Mobile Development, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Durum İçin Riverpod” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Flutter Mobile Development dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Flutter Mobile Development dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Flutter Mobile Development Sayfasına Dön