Sunnex Mobile Client

class ApiRepository {
  // Logic for Users
  Future<User> getUser() async {
    await Future.delayed(const Duration(seconds: 1));
    return User(name: "Gemini");
  }

  // Logic for Posts
  Future<List<String>> getPosts() async {
    await Future.delayed(const Duration(seconds: 1));
    return ["Post 1", "Post 2"];
  }
}

// Make the repository itself available via a provider
final apiRepositoryProvider = Provider((ref) => ApiRepository());

class UserNotifier extends AsyncNotifier<User> {
  @override
  FutureOr<User> build() {
    // Access the repository logic
    return ref.watch(apiRepositoryProvider).getUser();
  }

  // Action specific to users
  Future<void> updateName(String newName) async {
    state = const AsyncLoading();
    // Logic to update user...
  }
}

final userProvider = AsyncNotifierProvider<UserNotifier, User>(UserNotifier.new);

class PostsNotifier extends AsyncNotifier<List<String>> {
  @override
  FutureOr<List<String>> build() {
    return ref.watch(apiRepositoryProvider).getPosts();
  }
}

final postsProvider = AsyncNotifierProvider<PostsNotifier, List<String>>(PostsNotifier.new);

class DashboardScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Watch multiple providers independently
    final userAsync = ref.watch(userProvider);
    final postsAsync = ref.watch(postsProvider);

    return Scaffold(
      body: Column(
        children: [
          // User Section
          userAsync.when(
            data: (user) => Text("Welcome, ${user.name}"),
            loading: () => CircularProgressIndicator(),
            error: (e, _) => Text("User Error"),
          ),
          
          // Posts Section
          Expanded(
            child: postsAsync.when(
              data: (posts) => ListView(children: posts.map(Text.new).toList()),
              loading: () => Center(child: CircularProgressIndicator()),
              error: (e, _) => Text("Posts Error"),
            ),
          ),
        ],
      ),
    );
  }
}

@riverpod
Future<User> fetchUser(Ref ref) async {
  return ref.watch(apiRepositoryProvider).getUser();
}