admin1
638 lines
25 KiB
Dart
638 lines
25 KiB
Dart
import 'dart:async';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:forui/forui.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
|
|
import '../../core/contracts/auth.dart';
|
|
import '../../core/contracts/library.dart';
|
|
import '../../providers/di_providers.dart';
|
|
import '../../providers/emby_headers_provider.dart';
|
|
import '../../providers/home_banner_provider.dart';
|
|
import '../../providers/home_page_mode_provider.dart';
|
|
import '../../providers/library_overview_provider.dart';
|
|
import '../../providers/playback_active_provider.dart';
|
|
import '../../providers/server_provider.dart';
|
|
import '../../providers/session_provider.dart';
|
|
import '../../providers/shell_backdrop_provider.dart';
|
|
import '../../providers/tmdb_prefetch_provider.dart';
|
|
import '../../shared/mappers/media_image_url.dart';
|
|
import '../../shared/utils/color_utils.dart';
|
|
import '../../shared/utils/user_error_formatter.dart';
|
|
import '../../shared/widgets/add_server_modal.dart';
|
|
import '../../shared/widgets/app_dialog.dart';
|
|
import '../../shared/widgets/app_error_state.dart';
|
|
import '../../shared/widgets/app_loading_ring.dart';
|
|
import '../../shared/widgets/empty_state.dart';
|
|
import '../../shared/widgets/error_media_row.dart';
|
|
import '../../shared/utils/media_nav.dart';
|
|
import '../../shared/widgets/frosted_panel.dart';
|
|
import '../../shared/widgets/latest_media_row.dart';
|
|
import '../../shared/widgets/login_form.dart';
|
|
import '../../shared/widgets/media_poster_card.dart';
|
|
import '../../shared/constants/breakpoints.dart';
|
|
import '../../shared/widgets/scroll_fade_header.dart';
|
|
import '../../shared/widgets/skeleton_media_row.dart';
|
|
import '../discover/discover_page.dart';
|
|
import 'widgets/banner_carousel.dart';
|
|
import 'widgets/server_dropdown_button.dart';
|
|
|
|
class HomePage extends ConsumerWidget {
|
|
const HomePage({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
ref.listen<AuthedSession?>(activeSessionProvider, (previous, next) {
|
|
if (previous != null && next == null) {
|
|
ref.read(shellBackdropProvider.notifier).clear();
|
|
}
|
|
});
|
|
|
|
final sessionAsync = ref.watch(sessionProvider);
|
|
if (sessionAsync.isLoading && !sessionAsync.hasValue) {
|
|
return const Scaffold(
|
|
backgroundColor: Colors.transparent,
|
|
body: SizedBox.shrink(),
|
|
);
|
|
}
|
|
|
|
final session = ref.watch(activeSessionProvider);
|
|
if (session == null) return const _UnauthenticatedHome();
|
|
return _AuthenticatedHome(session: session);
|
|
}
|
|
}
|
|
|
|
class _UnauthenticatedHome extends ConsumerWidget {
|
|
const _UnauthenticatedHome();
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final servers = ref.watch(serverListProvider);
|
|
return Scaffold(
|
|
backgroundColor: Colors.transparent,
|
|
body: servers.when(
|
|
data: (list) {
|
|
final availableList = list.where((s) => !s.paused).toList();
|
|
|
|
if (list.isEmpty || availableList.isEmpty) {
|
|
return Center(
|
|
child: EmptyState(
|
|
icon: Icons.cloud_outlined,
|
|
title: list.isEmpty ? '尚未添加 Emby 服务器' : '所有服务器已暂停',
|
|
message: list.isEmpty
|
|
? '添加第一个服务器，开始构建你的影库。'
|
|
: '前往「服务器」页恢复使用，或添加新服务器。',
|
|
action: FButton(
|
|
variant: FButtonVariant.primary,
|
|
onPress: () => showAddServerModal(context),
|
|
child: const Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(Icons.add, size: 16),
|
|
SizedBox(width: 6),
|
|
Text('添加服务器'),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
return Center(
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.all(24),
|
|
child: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: 540),
|
|
child: FrostedPanel(
|
|
radius: 32,
|
|
padding: const EdgeInsets.all(28),
|
|
color: Theme.of(
|
|
context,
|
|
).colorScheme.surface.withValues(alpha: 0.72),
|
|
border: Border.all(
|
|
color: Colors.white.withValues(alpha: 0.22),
|
|
),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Text(
|
|
'选择服务器登录',
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
'所有内容都会以当前服务器为中心进行同步与推荐。',
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
const SizedBox(height: 18),
|
|
...availableList.map(
|
|
(server) => Padding(
|
|
padding: const EdgeInsets.only(bottom: 10),
|
|
child: FCard(
|
|
child: ListTile(
|
|
leading: const Icon(Icons.dns_outlined),
|
|
title: Text(server.name),
|
|
subtitle: Text(server.baseUrl),
|
|
onTap: () async {
|
|
await showAppRawDialog<void>(
|
|
context,
|
|
constraints: const BoxConstraints(
|
|
maxWidth: 460,
|
|
),
|
|
builder: (_) => Padding(
|
|
padding: const EdgeInsets.all(24),
|
|
child: LoginForm(
|
|
server: server,
|
|
onBack: () => Navigator.pop(context),
|
|
onSuccess: () => Navigator.pop(context),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
FButton(
|
|
variant: FButtonVariant.outline,
|
|
onPress: () => showAddServerModal(context),
|
|
child: const Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(Icons.add, size: 16),
|
|
SizedBox(width: 6),
|
|
Text('添加新服务器'),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
loading: () => const Center(child: AppLoadingRing()),
|
|
error: (error, _) => AppErrorState(
|
|
message: formatUserError(error, fallback: '登录态加载失败'),
|
|
onRetry: () => ref.invalidate(sessionProvider),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _AuthenticatedHome extends ConsumerStatefulWidget {
|
|
final AuthedSession session;
|
|
|
|
const _AuthenticatedHome({required this.session});
|
|
|
|
@override
|
|
ConsumerState<_AuthenticatedHome> createState() => _AuthenticatedHomeState();
|
|
}
|
|
|
|
class _AuthenticatedHomeState extends ConsumerState<_AuthenticatedHome> {
|
|
final Map<String, bool> _favoriteMap = {};
|
|
final Map<String, bool> _playedMap = {};
|
|
final Map<String, bool> _favoriteLoadingMap = {};
|
|
final Map<String, bool> _playedLoadingMap = {};
|
|
final Map<String, bool> _hideResumeLoadingMap = {};
|
|
final Set<String> _hiddenResumeIds = {};
|
|
|
|
final ScrollController _scrollController = ScrollController();
|
|
final ValueNotifier<double> _scrollProgress = ValueNotifier<double>(0.0);
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_scrollController.addListener(_handleScroll);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_scrollController.removeListener(_handleScroll);
|
|
_scrollController.dispose();
|
|
_scrollProgress.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
void _handleScroll() {
|
|
if (!_scrollController.hasClients) return;
|
|
const threshold = 120.0;
|
|
final progress = (_scrollController.offset / threshold).clamp(0.0, 1.0);
|
|
_scrollProgress.value = progress;
|
|
}
|
|
|
|
Future<void> _toggleFavorite(EmbyRawItem item) async {
|
|
if (_favoriteLoadingMap[item.Id] == true) return;
|
|
final next = !(_favoriteMap[item.Id] ?? item.UserData?.IsFavorite ?? false);
|
|
setState(() => _favoriteLoadingMap[item.Id] = true);
|
|
try {
|
|
final useCase = await ref.read(setFavoriteUseCaseProvider.future);
|
|
final result = await useCase.execute(
|
|
FavoriteSetReq(itemId: item.Id, isFavorite: next),
|
|
);
|
|
setState(() => _favoriteMap[item.Id] = result.isFavorite);
|
|
} finally {
|
|
setState(() => _favoriteLoadingMap[item.Id] = false);
|
|
}
|
|
}
|
|
|
|
Future<void> _togglePlayed(EmbyRawItem item) async {
|
|
if (_playedLoadingMap[item.Id] == true) return;
|
|
final next = !(_playedMap[item.Id] ?? item.UserData?.Played ?? false);
|
|
setState(() => _playedLoadingMap[item.Id] = true);
|
|
try {
|
|
final useCase = await ref.read(setPlayedUseCaseProvider.future);
|
|
final result = await useCase.execute(
|
|
PlayedSetReq(itemId: item.Id, played: next),
|
|
);
|
|
setState(() => _playedMap[item.Id] = result.played);
|
|
unawaited(_syncTraktPlayedChange(item, result.played));
|
|
} finally {
|
|
setState(() => _playedLoadingMap[item.Id] = false);
|
|
}
|
|
}
|
|
|
|
Future<void> _syncTraktPlayedChange(EmbyRawItem item, bool played) async {
|
|
try {
|
|
final service = await ref.read(traktSyncServiceProvider.future);
|
|
await service.syncEmbyPlayedChange(item: item, played: played);
|
|
} catch (_) {}
|
|
}
|
|
|
|
Future<void> _hideFromResume(EmbyRawItem item) async {
|
|
if (_hideResumeLoadingMap[item.Id] == true) return;
|
|
setState(() {
|
|
_hideResumeLoadingMap[item.Id] = true;
|
|
_hiddenResumeIds.add(item.Id);
|
|
});
|
|
try {
|
|
final useCase = await ref.read(hideFromResumeUseCaseProvider.future);
|
|
final result = await useCase.execute(
|
|
HideFromResumeReq(itemId: item.Id, hide: true),
|
|
);
|
|
if (!result.hide) {
|
|
setState(() => _hiddenResumeIds.remove(item.Id));
|
|
}
|
|
} catch (_) {
|
|
setState(() => _hiddenResumeIds.remove(item.Id));
|
|
} finally {
|
|
setState(() => _hideResumeLoadingMap[item.Id] = false);
|
|
}
|
|
}
|
|
|
|
bool _resolveFavorite(EmbyRawItem item) {
|
|
return _favoriteMap[item.Id] ?? item.UserData?.IsFavorite ?? false;
|
|
}
|
|
|
|
bool _resolvePlayed(EmbyRawItem item) {
|
|
return _playedMap[item.Id] ?? item.UserData?.Played ?? false;
|
|
}
|
|
|
|
Map<String, bool> _buildFavoriteMap(List<EmbyRawItem> items) {
|
|
return {for (final item in items) item.Id: _resolveFavorite(item)};
|
|
}
|
|
|
|
Map<String, bool> _buildPlayedMap(List<EmbyRawItem> items) {
|
|
return {for (final item in items) item.Id: _resolvePlayed(item)};
|
|
}
|
|
|
|
void _openMediaDetail(EmbyRawItem item) {
|
|
goMediaDetail(context, item, ref: ref);
|
|
}
|
|
|
|
EmbyRawItem? _lastBannerItem;
|
|
|
|
bool _isHomeForeground() {
|
|
return ref.read(shellLocationProvider) == '/' &&
|
|
!ref.read(detailPageActiveProvider);
|
|
}
|
|
|
|
void _updateShellBackdrop(EmbyRawItem item) {
|
|
_lastBannerItem = item;
|
|
if (!_isHomeForeground()) return;
|
|
|
|
final backdropUrl = EmbyImageUrl.detailBanner(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
);
|
|
final fallbackId = (item.SeriesId?.isNotEmpty ?? false)
|
|
? item.SeriesId!
|
|
: item.Id;
|
|
final fallbackUrls = <String>{
|
|
EmbyImageUrl.fanart(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
itemId: fallbackId,
|
|
),
|
|
backdropUrl,
|
|
}.toList();
|
|
final accentColor = _accentColorFor(item.Id);
|
|
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
if (!_isHomeForeground()) return;
|
|
ref
|
|
.read(shellBackdropProvider.notifier)
|
|
.show(
|
|
ShellBackdropState(
|
|
primaryImageUrl: backdropUrl,
|
|
fallbackImageUrls: fallbackUrls,
|
|
accentColor: accentColor,
|
|
),
|
|
);
|
|
});
|
|
}
|
|
|
|
void _clearShellBackdropDeferred() {
|
|
_lastBannerItem = null;
|
|
if (ref.read(shellBackdropProvider) == null) return;
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
if (!_isHomeForeground()) return;
|
|
ref.read(shellBackdropProvider.notifier).clear();
|
|
});
|
|
}
|
|
|
|
Color _accentColorFor(String seed) => accentColorForSeed(
|
|
seed,
|
|
isDark: Theme.of(context).brightness == Brightness.dark,
|
|
);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final isCompact = MediaQuery.sizeOf(context).width < Breakpoints.compact;
|
|
final mode = ref.watch(homePageModeProvider);
|
|
if (isCompact && mode == HomePageMode.recommend) {
|
|
return const DiscoverPage(embedInHome: true);
|
|
}
|
|
|
|
final state = ref.watch(libraryOverviewProvider);
|
|
final bannerAsync = ref.watch(homeBannerProvider);
|
|
final imageHeaders = ref.watch(embyImageHeadersProvider).value;
|
|
final dpr = MediaQuery.devicePixelRatioOf(context);
|
|
final homeForeground =
|
|
ref.watch(shellLocationProvider) == '/' &&
|
|
!ref.watch(detailPageActiveProvider);
|
|
ref.watch(tmdbPrefetchProvider);
|
|
|
|
ref.listen<String>(shellLocationProvider, (_, loc) {
|
|
if (loc != '/') return;
|
|
if (ref.read(detailPageActiveProvider)) return;
|
|
if (_lastBannerItem != null) {
|
|
_updateShellBackdrop(_lastBannerItem!);
|
|
} else {
|
|
_clearShellBackdropDeferred();
|
|
}
|
|
});
|
|
ref.listen<bool>(detailPageActiveProvider, (_, active) {
|
|
if (active) return;
|
|
if (ref.read(shellLocationProvider) != '/') return;
|
|
ref.read(libraryOverviewProvider.notifier).softRefresh();
|
|
if (_lastBannerItem != null) {
|
|
_updateShellBackdrop(_lastBannerItem!);
|
|
} else {
|
|
_clearShellBackdropDeferred();
|
|
}
|
|
});
|
|
|
|
return Scaffold(
|
|
backgroundColor: Colors.transparent,
|
|
body: state.when(
|
|
data: (data) {
|
|
if (data.libraries.isEmpty) {
|
|
_clearShellBackdropDeferred();
|
|
return const Center(
|
|
child: EmptyState(
|
|
icon: Icons.movie_filter_outlined,
|
|
title: '没有可用的媒体库',
|
|
),
|
|
);
|
|
}
|
|
|
|
final resumeItems = data.resumeItems
|
|
.where((item) => !_hiddenResumeIds.contains(item.Id))
|
|
.toList();
|
|
|
|
return Stack(
|
|
children: [
|
|
RefreshIndicator(
|
|
onRefresh: () => Future.wait([
|
|
ref.read(libraryOverviewProvider.notifier).softRefresh(),
|
|
ref.read(homeBannerProvider.notifier).softRefresh(),
|
|
]),
|
|
displacement: 72,
|
|
child: ListView(
|
|
controller: _scrollController,
|
|
physics: const AlwaysScrollableScrollPhysics(
|
|
parent: BouncingScrollPhysics(),
|
|
),
|
|
padding: EdgeInsets.only(top: isCompact ? 0 : 60, bottom: 32),
|
|
children: [
|
|
bannerAsync.when(
|
|
data: (bannerItems) {
|
|
if (bannerItems.isEmpty) {
|
|
_clearShellBackdropDeferred();
|
|
return const SizedBox.shrink(
|
|
key: ValueKey('home-banner-empty'),
|
|
);
|
|
}
|
|
return Padding(
|
|
key: const ValueKey('home-banner'),
|
|
padding: const EdgeInsets.only(bottom: 16),
|
|
child: HomeBannerCarousel(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
items: bannerItems,
|
|
imageHeaders: imageHeaders,
|
|
onItemTap: _openMediaDetail,
|
|
onActiveItemChanged: _updateShellBackdrop,
|
|
active: homeForeground,
|
|
),
|
|
);
|
|
},
|
|
loading: () => const Padding(
|
|
key: ValueKey('home-banner-loading'),
|
|
padding: EdgeInsets.only(bottom: 16),
|
|
child: HomeBannerSkeleton(),
|
|
),
|
|
error: (_, _) {
|
|
_clearShellBackdropDeferred();
|
|
return const SizedBox.shrink(
|
|
key: ValueKey('home-banner-error'),
|
|
);
|
|
},
|
|
),
|
|
if (data.resumeLoading)
|
|
const SkeletonMediaRow(
|
|
key: ValueKey('home-resume-row'),
|
|
title: '继续观看',
|
|
cardVariant: MediaCardVariant.landscape,
|
|
titleColor: Colors.white,
|
|
)
|
|
else if (data.resumeError != null)
|
|
ErrorMediaRow(
|
|
key: const ValueKey('home-resume-row'),
|
|
title: '继续观看',
|
|
cardVariant: MediaCardVariant.landscape,
|
|
titleColor: Colors.white,
|
|
onRetry: () => ref
|
|
.read(libraryOverviewProvider.notifier)
|
|
.retryResume(),
|
|
)
|
|
else if (resumeItems.isNotEmpty)
|
|
LatestMediaRow(
|
|
key: const ValueKey('home-resume-row'),
|
|
title: '继续观看',
|
|
items: resumeItems,
|
|
cardVariant: MediaCardVariant.landscape,
|
|
enableContextMenu: true,
|
|
favoriteMap: _buildFavoriteMap(resumeItems),
|
|
playedMap: _buildPlayedMap(resumeItems),
|
|
favoriteLoadingMap: _favoriteLoadingMap,
|
|
playedLoadingMap: _playedLoadingMap,
|
|
onAddFavorite: _toggleFavorite,
|
|
onMarkPlayed: _togglePlayed,
|
|
onHideFromResume: _hideFromResume,
|
|
hideFromResumeLoadingMap: _hideResumeLoadingMap,
|
|
imageHeaders: imageHeaders,
|
|
titleColor: Colors.white,
|
|
imageUrlBuilder: (item) => EmbyImageUrl.landscapeCard(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
maxWidth: EmbyImageUrl.targetPixelWidth(232, dpr),
|
|
),
|
|
preloadImageUrlBuilder: (item) =>
|
|
EmbyImageUrl.detailBanner(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
),
|
|
onItemTap: _openMediaDetail,
|
|
),
|
|
if (data.libraries.isNotEmpty)
|
|
LatestMediaRow(
|
|
key: const ValueKey('home-library-row'),
|
|
title: '我的媒体列表',
|
|
items: data.libraries
|
|
.map(
|
|
(library) => EmbyRawItem(
|
|
Id: library.Id,
|
|
Name: library.Name,
|
|
PrimaryImageTag: library.ImageTags?['Primary'],
|
|
ImageTags: library.ImageTags,
|
|
),
|
|
)
|
|
.toList(),
|
|
cardVariant: MediaCardVariant.landscape,
|
|
showHoverPlayIcon: false,
|
|
imageHeaders: imageHeaders,
|
|
titleColor: Colors.white,
|
|
imageUrlBuilder: (item) => EmbyImageUrl.primary(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
maxWidth: EmbyImageUrl.targetPixelWidth(232, dpr),
|
|
),
|
|
onItemTap: (item) =>
|
|
context.push('/library/${item.Id}'),
|
|
),
|
|
...data.libraries.expand((library) {
|
|
final isLoading = data.loadingLibraryIds.contains(
|
|
library.Id,
|
|
);
|
|
if (isLoading) {
|
|
return [
|
|
SkeletonMediaRow(
|
|
key: ValueKey('home-latest-row-${library.Id}'),
|
|
title: '${library.Name} · 最新更新',
|
|
titleColor: Colors.white,
|
|
),
|
|
];
|
|
}
|
|
final error = data.latestErrorByLibrary[library.Id];
|
|
if (error != null) {
|
|
return [
|
|
ErrorMediaRow(
|
|
key: ValueKey('home-latest-row-${library.Id}'),
|
|
title: '${library.Name} · 最新更新',
|
|
titleColor: Colors.white,
|
|
onRetry: () => ref
|
|
.read(libraryOverviewProvider.notifier)
|
|
.retryLatest(library.Id),
|
|
),
|
|
];
|
|
}
|
|
final items =
|
|
data.latestByLibrary[library.Id] ??
|
|
const <EmbyRawItem>[];
|
|
if (items.isEmpty) return const <Widget>[];
|
|
return [
|
|
LatestMediaRow(
|
|
key: ValueKey('home-latest-row-${library.Id}'),
|
|
title: library.Name,
|
|
subtitle: '最新更新',
|
|
items: items,
|
|
totalCount: data.totalCountByLibrary[library.Id],
|
|
enableContextMenu: true,
|
|
favoriteMap: _buildFavoriteMap(items),
|
|
playedMap: _buildPlayedMap(items),
|
|
favoriteLoadingMap: _favoriteLoadingMap,
|
|
playedLoadingMap: _playedLoadingMap,
|
|
onAddFavorite: _toggleFavorite,
|
|
onMarkPlayed: _togglePlayed,
|
|
imageHeaders: imageHeaders,
|
|
titleColor: Colors.white,
|
|
imageUrlBuilder: (item) => EmbyImageUrl.primary(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
maxWidth: EmbyImageUrl.targetPixelWidth(158, dpr),
|
|
),
|
|
preloadImageUrlBuilder: (item) =>
|
|
EmbyImageUrl.detailBanner(
|
|
baseUrl: widget.session.serverUrl,
|
|
token: widget.session.token,
|
|
item: item,
|
|
),
|
|
onItemTap: _openMediaDetail,
|
|
onSeeAll: () =>
|
|
context.push('/library/${library.Id}'),
|
|
),
|
|
];
|
|
}),
|
|
],
|
|
),
|
|
),
|
|
if (MediaQuery.sizeOf(context).width < Breakpoints.compact)
|
|
Positioned(
|
|
top: MediaQuery.paddingOf(context).top + 8,
|
|
left: 16,
|
|
child: const ServerDropdownButton(),
|
|
)
|
|
else
|
|
Positioned(
|
|
top: 0,
|
|
left: 0,
|
|
right: 0,
|
|
child: ScrollFadeHeader(scrollProgress: _scrollProgress),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
loading: () => const Center(child: AppLoadingRing()),
|
|
error: (error, _) => AppErrorState(
|
|
message: formatUserError(error, fallback: '首页内容加载失败'),
|
|
panel: true,
|
|
onRetry: () => ref.read(libraryOverviewProvider.notifier).refresh(),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|