Bloc10

//main.dart
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'repository_bloc.dart';
import 'repository.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return RepositoryProvider(
      create: (context) => YourRepository(),
      child: BlocProvider(
        create: (context) =>
            YourBloc(repository: context.read<YourRepository>()),
        child: MaterialApp(
          title: 'Flutter Demo',
          theme: ThemeData(
            primarySwatch: Colors.blue,
          ),
          home: MyHomePage(),
        ),
      ),
    );
  }
}

class MyHomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Home Page'),
      ),
      body: Center(
        child: BlocBuilder<YourBloc, YourState>(
          builder: (context, state) {
            if (state is YourLoading) {
              return CircularProgressIndicator();
            } else if (state is YourLoaded) {
              return Text(state.data);
            } else if (state is YourError) {
              return Text('Error');
            } else {
              return Text('Press button to fetch data');
            }
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => context.read<YourBloc>().add(FetchData()),
        child: Icon(Icons.download),
      ),
    );
  }
}

//lib\repository.dart
class YourRepository {
  Future<String> fetchData() async {
    // 這裡是你的資料取得邏輯，例如從API或本地資料庫取得資料
    // 在這個範例中，我們只是簡單地回傳一個字串
    await Future.delayed(Duration(seconds: 1)); // 模擬網路延遲
    String currentTime = DateTime.now().toString();
    return 'Hello, World! Current time: $currentTime';
  }
}

//lib\repository_bloc.dart
import 'package:flutter_bloc/flutter_bloc.dart';
import 'repository.dart';

class YourBloc extends Bloc<YourEvent, YourState> {
  final YourRepository repository;

  YourBloc({required this.repository}) : super(YourInitial()) {
    on<FetchData>((event, emit) async {
      emit(YourLoading());
      try {
        final data = await repository.fetchData();
        emit(YourLoaded(data: data));
      } catch (_) {
        emit(YourError());
      }
    });
  }
}

abstract class YourEvent {}

class FetchData extends YourEvent {}

abstract class YourState {}

class YourInitial extends YourState {}

class YourLoading extends YourState {}

class YourLoaded extends YourState {
  final String data;

  YourLoaded({required this.data});
}

class YourError extends YourState {}

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:http/http.dart';
import 'dart:convert';

void main() {
  runApp(const MaterialApp(
    home: Scaffold(body: UsersPage()),
  ));
}

class UsersRepository {
  Future<List<User>> getUsers() async {
    final response =
        await get(Uri.parse('https://jsonplaceholder.typicode.com/users'));
    if (response.statusCode == 200) {
      final users = json.decode(response.body) as List;
      return users.map((user) => User.fromJson(user)).toList();
    } else {
      throw Exception('Error fetching users');
    }
  }
}

class User {
  final int? id;
  final String? name;
  final String? email;

  User({this.id, this.name, this.email});

  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
}

class UsersBloc extends Bloc<UsersEvent, UsersState> {
  final UsersRepository usersRepository;

  UsersBloc({required this.usersRepository}) : super(UsersInitial()) {
    on<UsersFetched>((event, emit) async {
      try {
        final users = await usersRepository.getUsers();
        emit(UsersLoaded(users: users));
      } catch (e) {
        emit(UsersError(error: e.toString()));
      }
    });
  }
}

abstract class UsersEvent {}

class UsersFetched extends UsersEvent {}

abstract class UsersState {}

class UsersInitial extends UsersState {}

class UsersLoaded extends UsersState {
  final List<User> users;

  UsersLoaded({required this.users});
}

class UsersError extends UsersState {
  final String error;

  UsersError({required this.error});
}

class UsersPage extends StatelessWidget {
  const UsersPage({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (context) {
        final bloc = UsersBloc(usersRepository: UsersRepository());
        bloc.add(UsersFetched()); // 觸發事件來獲取用戶數據
        return bloc;
      },
      child: BlocBuilder<UsersBloc, UsersState>(
        builder: (context, state) {
          if (state is UsersError) {
            return Center(
              child: Text(state.error),
            );
          } else if (state is UsersLoaded && state.users.isEmpty) {
            return Center(
              child: const CircularProgressIndicator(),
            );
          } else if (state is UsersLoaded) {
            return ListView.builder(
              itemCount: state.users.length,
              itemBuilder: (context, index) {
                final user = state.users[index];
                return ListTile(
                  title: Text(user.name!),
                  subtitle: Text(user.email!),
                );
              },
            );
          } else {
            return Container();
          }
        },
      ),
    );
  }
}