509 lines
17 KiB
Dart
509 lines
17 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import 'package:cached_network_image/cached_network_image.dart';
|
|
import 'package:flutter_cache_manager/file.dart';
|
|
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:pullex/pullex.dart';
|
|
import 'package:share_plus/share_plus.dart';
|
|
|
|
import 'package:f0ckapp/services/api.dart';
|
|
import 'package:f0ckapp/widgets/tagfooter.dart';
|
|
import 'package:f0ckapp/utils/animatedtransition.dart';
|
|
import 'package:f0ckapp/controller/authcontroller.dart';
|
|
import 'package:f0ckapp/widgets/favoritesection.dart';
|
|
import 'package:f0ckapp/screens/fullscreen.dart';
|
|
import 'package:f0ckapp/widgets/end_drawer.dart';
|
|
import 'package:f0ckapp/controller/settingscontroller.dart';
|
|
import 'package:f0ckapp/controller/mediacontroller.dart';
|
|
import 'package:f0ckapp/models/item.dart';
|
|
import 'package:f0ckapp/widgets/tagsection.dart';
|
|
import 'package:f0ckapp/widgets/video_widget.dart';
|
|
|
|
enum ShareAction { media, directLink, postLink }
|
|
|
|
class MediaDetailScreen extends StatefulWidget {
|
|
final int initialId;
|
|
const MediaDetailScreen({super.key, required this.initialId});
|
|
|
|
@override
|
|
State<MediaDetailScreen> createState() => _MediaDetailScreenState();
|
|
}
|
|
|
|
class _MediaDetailScreenState extends State<MediaDetailScreen> {
|
|
PageController? _pageController;
|
|
final MediaController mediaController = Get.find<MediaController>();
|
|
final SettingsController settingsController = Get.find<SettingsController>();
|
|
final AuthController authController = Get.find<AuthController>();
|
|
final RxInt _currentIndex = 0.obs;
|
|
final MethodChannel _mediaSaverChannel = const MethodChannel('MediaShit');
|
|
final Map<int, PullexRefreshController> _refreshControllers = {};
|
|
final Map<int, GlobalKey<VideoWidgetState>> _videoWidgetKeys = {};
|
|
|
|
bool _isLoading = true;
|
|
bool _itemNotFound = false;
|
|
final Set<int> _readyItemIds = {};
|
|
final Map<int, bool> _showFavoriteAnimation = {};
|
|
|
|
final List<PopupMenuEntry<ShareAction>> _shareMenuItems = const [
|
|
PopupMenuItem(
|
|
value: ShareAction.media,
|
|
child: ListTile(leading: Icon(Icons.image), title: Text('Als Datei')),
|
|
),
|
|
PopupMenuItem(
|
|
value: ShareAction.directLink,
|
|
child: ListTile(leading: Icon(Icons.link), title: Text('Link zur Datei')),
|
|
),
|
|
PopupMenuItem(
|
|
value: ShareAction.postLink,
|
|
child: ListTile(
|
|
leading: Icon(Icons.article),
|
|
title: Text('Link zum f0ck'),
|
|
),
|
|
),
|
|
];
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_loadInitialItem();
|
|
}
|
|
|
|
Future<void> _loadInitialItem() async {
|
|
int initialIndex = mediaController.items.indexWhere(
|
|
(item) => item.id == widget.initialId,
|
|
);
|
|
|
|
if (initialIndex < 0) {
|
|
await mediaController.fetchInitial(id: widget.initialId + 20);
|
|
initialIndex = mediaController.items.indexWhere(
|
|
(item) => item.id == widget.initialId,
|
|
);
|
|
}
|
|
|
|
if (initialIndex < 0) {
|
|
if (mounted) {
|
|
setState(() {
|
|
_itemNotFound = true;
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (mounted) {
|
|
_currentIndex.value = initialIndex;
|
|
_pageController = PageController(initialPage: initialIndex);
|
|
if (mediaController.items[initialIndex].mime.startsWith('image/')) {
|
|
_readyItemIds.add(mediaController.items[initialIndex].id);
|
|
}
|
|
setState(() => _isLoading = false);
|
|
}
|
|
}
|
|
|
|
void _showMsg(String message) {
|
|
if (!mounted) return;
|
|
Get
|
|
..closeAllSnackbars()
|
|
..snackbar('hehe', message, snackPosition: SnackPosition.BOTTOM);
|
|
}
|
|
|
|
Future<void> _onRefresh(
|
|
int itemId,
|
|
PullexRefreshController controller,
|
|
) async {
|
|
if (mediaController.loading.value) {
|
|
controller.refreshCompleted();
|
|
return;
|
|
}
|
|
|
|
try {
|
|
final MediaItem item = await ApiService().fetchItemById(itemId);
|
|
final int index = mediaController.items.indexWhere(
|
|
(item) => item.id == itemId,
|
|
);
|
|
if (index != -1) {
|
|
mediaController.items[index] = item;
|
|
mediaController.items.refresh();
|
|
}
|
|
controller.refreshCompleted();
|
|
} catch (e) {
|
|
_showMsg('Fehler beim Aktualisieren: $e');
|
|
controller.refreshFailed();
|
|
}
|
|
}
|
|
|
|
void _onPageChanged(int idx) {
|
|
if (idx != _currentIndex.value) {
|
|
_currentIndex.value = idx;
|
|
final MediaItem item = mediaController.items[idx];
|
|
if (item.mime.startsWith('image/') && !_readyItemIds.contains(item.id)) {
|
|
setState(() => _readyItemIds.add(item.id));
|
|
}
|
|
}
|
|
|
|
if (idx + 1 < mediaController.items.length) {
|
|
DefaultCacheManager().downloadFile(
|
|
mediaController.items[idx + 1].mediaUrl,
|
|
);
|
|
}
|
|
if (idx - 1 >= 0) {
|
|
DefaultCacheManager().downloadFile(
|
|
mediaController.items[idx - 1].mediaUrl,
|
|
);
|
|
}
|
|
|
|
if (idx >= mediaController.items.length - 2 &&
|
|
!mediaController.loading.value &&
|
|
!mediaController.atEnd.value) {
|
|
mediaController.fetchMore();
|
|
} else if (idx <= 1 &&
|
|
!mediaController.loading.value &&
|
|
!mediaController.atStart.value) {
|
|
mediaController.fetchNewer();
|
|
}
|
|
}
|
|
|
|
Future<void> _downloadMedia(MediaItem item) async {
|
|
try {
|
|
final File file = await DefaultCacheManager().getSingleFile(
|
|
item.mediaUrl,
|
|
);
|
|
|
|
final bool? success = await _mediaSaverChannel.invokeMethod<bool>(
|
|
'saveFile',
|
|
{'filePath': file.path, 'fileName': item.dest},
|
|
);
|
|
|
|
success == true
|
|
? _showMsg('${item.dest} wurde in Downloads/fApp neigespeichert.')
|
|
: _showMsg('${item.dest} konnte nicht heruntergeladen werden.');
|
|
} catch (e) {
|
|
_showMsg('Fehler beim Download: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> _handleShareAction(ShareAction value, MediaItem item) async {
|
|
try {
|
|
if (value == ShareAction.media) {
|
|
final File file = await DefaultCacheManager().getSingleFile(
|
|
item.mediaUrl,
|
|
);
|
|
final Uint8List bytes = await file.readAsBytes();
|
|
final ShareParams params = ShareParams(
|
|
files: [XFile.fromData(bytes, mimeType: item.mime)],
|
|
);
|
|
await SharePlus.instance.share(params);
|
|
return;
|
|
}
|
|
|
|
final String textToShare;
|
|
switch (value) {
|
|
case ShareAction.directLink:
|
|
textToShare = item.mediaUrl;
|
|
break;
|
|
case ShareAction.postLink:
|
|
textToShare = item.postUrl;
|
|
break;
|
|
case ShareAction.media:
|
|
return;
|
|
}
|
|
await SharePlus.instance.share(ShareParams(text: textToShare));
|
|
} catch (e) {
|
|
_showMsg('Fehler beim Teilen: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> _handleFullScreen(MediaItem currentItem) async {
|
|
if (currentItem.mime.startsWith('image')) {
|
|
Get.to(
|
|
() => FullScreenMediaView(item: currentItem),
|
|
fullscreenDialog: true,
|
|
);
|
|
return;
|
|
}
|
|
|
|
final GlobalKey<VideoWidgetState>? key = _videoWidgetKeys[currentItem.id];
|
|
final VideoWidgetState? videoState = key?.currentState;
|
|
if (videoState == null || !videoState.videoController.value.isInitialized) {
|
|
return;
|
|
}
|
|
|
|
final Duration position = videoState.videoController.value.position;
|
|
await videoState.videoController.pause();
|
|
|
|
final Duration? newPosition = await Get.to<Duration?>(
|
|
() => FullScreenMediaView(item: currentItem, initialPosition: position),
|
|
fullscreenDialog: true,
|
|
);
|
|
|
|
if (mounted && videoState.mounted) {
|
|
if (newPosition != null) {
|
|
await videoState.videoController.seekTo(newPosition);
|
|
}
|
|
await videoState.videoController.play();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_pageController?.dispose();
|
|
for (PullexRefreshController controller in _refreshControllers.values) {
|
|
controller.dispose();
|
|
}
|
|
super.dispose();
|
|
}
|
|
|
|
Future<void> _handleFavoriteToggle(MediaItem item, bool isFavorite) async {
|
|
if (!authController.isLoggedIn) return;
|
|
HapticFeedback.lightImpact();
|
|
|
|
final List<Favorite>? newFavorites = await mediaController.toggleFavorite(
|
|
item,
|
|
isFavorite,
|
|
);
|
|
|
|
final int index = mediaController.items.indexWhere((i) => i.id == item.id);
|
|
|
|
if (newFavorites != null && index != -1) {
|
|
mediaController.items[index] = item.copyWith(favorites: newFavorites);
|
|
mediaController.items.refresh();
|
|
}
|
|
|
|
if (!mounted) return;
|
|
setState(() => _showFavoriteAnimation[item.id] = true);
|
|
Future.delayed(const Duration(milliseconds: 700), () {
|
|
if (mounted) {
|
|
setState(() => _showFavoriteAnimation[item.id] = false);
|
|
}
|
|
});
|
|
}
|
|
|
|
Widget _buildMedia(MediaItem item, bool isActive) {
|
|
Widget mediaWidget;
|
|
if (item.mime.startsWith('image/')) {
|
|
mediaWidget = CachedNetworkImage(
|
|
imageUrl: item.mediaUrl,
|
|
fit: BoxFit.contain,
|
|
placeholder: (context, url) =>
|
|
const Center(child: CircularProgressIndicator()),
|
|
errorWidget: (c, e, s) => const Icon(Icons.broken_image, size: 100),
|
|
);
|
|
} else if (item.mime.startsWith('video/') ||
|
|
item.mime.startsWith('audio/')) {
|
|
final key = _videoWidgetKeys.putIfAbsent(
|
|
item.id,
|
|
() => GlobalKey<VideoWidgetState>(),
|
|
);
|
|
mediaWidget = VideoWidget(
|
|
key: key,
|
|
details: item,
|
|
isActive: isActive,
|
|
onInitialized: () {
|
|
if (mounted && !_readyItemIds.contains(item.id)) {
|
|
setState(() => _readyItemIds.add(item.id));
|
|
}
|
|
},
|
|
);
|
|
} else {
|
|
mediaWidget = const Icon(Icons.help_outline, size: 100);
|
|
}
|
|
|
|
final bool isFavorite =
|
|
item.favorites?.any((f) => f.userId == authController.user.value?.id) ??
|
|
false;
|
|
|
|
return Hero(
|
|
tag: 'media_${item.id}',
|
|
child: GestureDetector(
|
|
onDoubleTap: () => _handleFavoriteToggle(item, isFavorite),
|
|
child: Stack(
|
|
alignment: Alignment.center,
|
|
children: [
|
|
mediaWidget,
|
|
AnimatedOpacity(
|
|
opacity: _showFavoriteAnimation[item.id] ?? false ? 1.0 : 0.0,
|
|
duration: const Duration(milliseconds: 200),
|
|
child: AnimatedScale(
|
|
scale: _showFavoriteAnimation[item.id] ?? false ? 1.0 : 0.5,
|
|
duration: const Duration(milliseconds: 400),
|
|
curve: Curves.easeOutBack,
|
|
child: Icon(
|
|
isFavorite ? Icons.favorite : Icons.favorite_outline,
|
|
color: Colors.red,
|
|
size: 100,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
if (_isLoading) {
|
|
return Scaffold(
|
|
appBar: AppBar(title: Text('Lade f0ck #${widget.initialId}...')),
|
|
body: const Center(child: CircularProgressIndicator()),
|
|
);
|
|
}
|
|
|
|
if (_itemNotFound) {
|
|
return Scaffold(
|
|
appBar: AppBar(title: const Text('Fehler')),
|
|
body: const Center(child: Text('f0ck nicht gefunden.')),
|
|
);
|
|
}
|
|
|
|
return Obx(() {
|
|
if (mediaController.items.isEmpty ||
|
|
_currentIndex.value >= mediaController.items.length) {
|
|
return Scaffold(
|
|
appBar: AppBar(title: const Text('Fehler')),
|
|
body: const Center(child: Text('Keine Items zum Anzeigen.')),
|
|
);
|
|
}
|
|
final MediaItem currentItem = mediaController.items[_currentIndex.value];
|
|
return Scaffold(
|
|
endDrawer: const EndDrawer(),
|
|
endDrawerEnableOpenDragGesture:
|
|
settingsController.drawerSwipeEnabled.value,
|
|
appBar: AppBar(
|
|
title: Text('f0ck #${currentItem.id}'),
|
|
actions: [
|
|
IconButton(
|
|
icon: const Icon(Icons.fullscreen),
|
|
onPressed: () => _handleFullScreen(currentItem),
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.download),
|
|
onPressed: () async => await _downloadMedia(currentItem),
|
|
),
|
|
PopupMenuButton<ShareAction>(
|
|
onSelected: (value) => _handleShareAction(value, currentItem),
|
|
itemBuilder: (context) => _shareMenuItems,
|
|
icon: const Icon(Icons.share),
|
|
),
|
|
Builder(
|
|
builder: (context) => IconButton(
|
|
icon: const Icon(Icons.menu),
|
|
onPressed: () => Scaffold.of(context).openEndDrawer(),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
body: Stack(
|
|
children: [
|
|
PageView.builder(
|
|
controller: _pageController!,
|
|
itemCount: mediaController.items.length,
|
|
onPageChanged: _onPageChanged,
|
|
itemBuilder: (context, index) {
|
|
final MediaItem item = mediaController.items[index];
|
|
final bool isReady = _readyItemIds.contains(item.id);
|
|
final PullexRefreshController refreshController =
|
|
_refreshControllers.putIfAbsent(
|
|
item.id,
|
|
() => PullexRefreshController(),
|
|
);
|
|
|
|
return PullexRefresh(
|
|
onRefresh: () => _onRefresh(item.id, refreshController),
|
|
header: const WaterDropHeader(),
|
|
controller: refreshController,
|
|
child: CustomScrollView(
|
|
slivers: [
|
|
SliverToBoxAdapter(
|
|
child: AnimatedBuilder(
|
|
animation: _pageController!,
|
|
builder: (context, child) {
|
|
return buildAnimatedTransition(
|
|
context: context,
|
|
pageController: _pageController!,
|
|
index: index,
|
|
child: child!,
|
|
);
|
|
},
|
|
child: Obx(
|
|
() =>
|
|
_buildMedia(item, index == _currentIndex.value),
|
|
),
|
|
),
|
|
),
|
|
if (isReady)
|
|
SliverFillRemaining(
|
|
hasScrollBody: false,
|
|
fillOverscroll: true,
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(16.0),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: [TagSection(tags: item.tags ?? [])],
|
|
),
|
|
),
|
|
),
|
|
const SliverToBoxAdapter(
|
|
child: SafeArea(child: SizedBox.shrink()),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Obx(() {
|
|
if (!authController.isLoggedIn) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
final MediaItem currentItem =
|
|
mediaController.items[_currentIndex.value];
|
|
|
|
final bool hasSoftButtons =
|
|
MediaQuery.of(context).padding.bottom > 24.0;
|
|
|
|
return DraggableScrollableSheet(
|
|
initialChildSize: hasSoftButtons ? 0.11 : 0.2,
|
|
minChildSize: hasSoftButtons ? 0.11 : 0.2,
|
|
maxChildSize: hasSoftButtons ? 0.245 : 0.2,
|
|
snap: true,
|
|
builder: (context, scrollController) => ListView(
|
|
controller: scrollController,
|
|
padding: const EdgeInsets.only(left: 16, right: 16),
|
|
children: [
|
|
FavoriteSection(
|
|
item: currentItem,
|
|
index: _currentIndex.value,
|
|
),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
"Dateigröße: ${(currentItem.size / 1024).toStringAsFixed(1)} KB",
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
Text(
|
|
"Typ: ${currentItem.mime}",
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
Text(
|
|
"ID: ${currentItem.id}",
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
Text(
|
|
"Hochgeladen am: ${DateTime.fromMillisecondsSinceEpoch(currentItem.stamp * 1000)}",
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}),
|
|
],
|
|
),
|
|
persistentFooterButtons: mediaController.tag.value != null
|
|
? [TagFooter()]
|
|
: null,
|
|
);
|
|
});
|
|
}
|
|
}
|