424 lines
16 KiB
Dart
424 lines
16 KiB
Dart
import 'dart:async';
|
||
import 'dart:io';
|
||
import 'dart:ui';
|
||
|
||
import 'package:audio_service/audio_service.dart';
|
||
import 'package:flutter/material.dart';
|
||
import 'package:provider/provider.dart';
|
||
|
||
import 'downloads/downloads_screen.dart';
|
||
import 'downloads/youtube_search_screen.dart';
|
||
import 'library/android_scan.dart';
|
||
import 'library/auto_scan.dart';
|
||
import 'library/category_service.dart';
|
||
import 'library/database.dart';
|
||
import 'library/favorites_screen.dart';
|
||
import 'library/library_service.dart';
|
||
import 'library/my_music_screen.dart';
|
||
import 'library/playlist_service.dart';
|
||
import 'library/search_screen.dart';
|
||
import 'player/audio_effects.dart';
|
||
import 'player/audio_handler.dart';
|
||
import 'player/mini_player.dart';
|
||
import 'player/now_playing_screen.dart';
|
||
import 'player/player_expansion_controller.dart';
|
||
import 'services/baka_auth.dart';
|
||
import 'services/logger_service.dart';
|
||
import 'services/download_service.dart';
|
||
import 'services/geteilte_adresse.dart';
|
||
import 'services/melo_cloud_service.dart';
|
||
import 'services/offline_mode.dart';
|
||
import 'services/navidrome_service.dart';
|
||
import 'services/sync_service.dart';
|
||
import 'services/yt_download_service.dart';
|
||
import 'services/yt_search_service.dart';
|
||
import 'settings/app_settings.dart';
|
||
import 'shared/theme.dart';
|
||
|
||
late final MeloAudioHandler _handler;
|
||
late final MeloDb _db;
|
||
late final LibraryService _library;
|
||
late final PlaylistService _playlists;
|
||
late final OfflineMode _offlineMode;
|
||
late final CategoryService _categories;
|
||
late final AppSettings _settings;
|
||
late final AudioEffects _effects;
|
||
late final BakaAuth _bakaAuth;
|
||
late final YtDownloadService _ytDownload;
|
||
late final YtSearchService _ytSearch;
|
||
late final SyncService _sync;
|
||
late final DownloadService _downloads;
|
||
|
||
Future<void> main() async {
|
||
WidgetsFlutterBinding.ensureInitialized();
|
||
await logger.init();
|
||
_db = MeloDb();
|
||
_library = LibraryService(_db);
|
||
_playlists = PlaylistService(_db);
|
||
_offlineMode = OfflineMode();
|
||
await _offlineMode.init();
|
||
_categories = CategoryService(_db);
|
||
_settings = AppSettings();
|
||
await _settings.init();
|
||
_handler = await AudioService.init(
|
||
builder: () => MeloAudioHandler(db: _db),
|
||
config: const AudioServiceConfig(
|
||
androidNotificationChannelId: 'de.baka.melo.audio',
|
||
androidNotificationChannelName: 'Melo',
|
||
androidNotificationOngoing: true,
|
||
androidShowNotificationBadge: true,
|
||
// Android Auto zeigt die oberste Ebene als Reiter statt als Liste —
|
||
// vier Ordner passen dort gut hin.
|
||
androidBrowsableRootExtras: {
|
||
'android.media.browse.CONTENT_STYLE_BROWSABLE_HINT': 2,
|
||
'android.media.browse.CONTENT_STYLE_PLAYABLE_HINT': 1,
|
||
},
|
||
),
|
||
);
|
||
_effects = AudioEffects();
|
||
await _effects.init();
|
||
_bakaAuth = BakaAuth();
|
||
await _bakaAuth.laden();
|
||
_ytDownload = YtDownloadService(auth: _bakaAuth);
|
||
_ytSearch = YtSearchService(auth: _bakaAuth);
|
||
_sync = SyncService(
|
||
db: _db,
|
||
cloud: MeloCloudService(auth: _bakaAuth),
|
||
);
|
||
await _sync.laden();
|
||
final navidrome = NavidromeService();
|
||
await navidrome.ladeGespeicherteZugangsdaten();
|
||
_downloads = DownloadService(db: _db, navidrome: navidrome);
|
||
// Die Audio-Session steht erst beim Abspielen fest und kann wechseln —
|
||
// die Klangeffekte müssen dann neu daran gehängt werden.
|
||
_handler.androidAudioSessionIdStream.listen((id) {
|
||
if (id != null) _effects.attach(id);
|
||
});
|
||
void uebernehmeEinstellungen() {
|
||
_handler.autoPlayOnHeadphones = _settings.autoPlayOnHeadphones;
|
||
_handler.normalizeVolume = _settings.normalizeVolume;
|
||
_handler.cacheGrenzeBytes = _settings.cacheGrenzeBytes;
|
||
// Sofort anwenden: wer die Grenze senkt, will nicht warten, bis zufällig
|
||
// der nächste Titel gestreamt wird.
|
||
unawaited(_handler.raeumeZwischenspeicherAuf());
|
||
}
|
||
|
||
uebernehmeEinstellungen();
|
||
_settings.addListener(uebernehmeEinstellungen);
|
||
|
||
// Der Offline-Schalter liegt in einem eigenen Dienst, wirkt aber genauso:
|
||
// ohne diese Weitergabe war er nur gespeichert und die App streamte weiter.
|
||
void uebernehmeOfflineModus() => _handler.offlineOnly = _offlineMode.enabled;
|
||
uebernehmeOfflineModus();
|
||
_offlineMode.addListener(uebernehmeOfflineModus);
|
||
|
||
runApp(const MeloApp());
|
||
}
|
||
|
||
class MeloApp extends StatelessWidget {
|
||
const MeloApp({super.key});
|
||
|
||
@override
|
||
Widget build(BuildContext context) {
|
||
return MultiProvider(
|
||
providers: [
|
||
Provider<MeloAudioHandler>.value(value: _handler),
|
||
Provider<MeloDb>.value(value: _db),
|
||
ChangeNotifierProvider<LibraryService>.value(value: _library),
|
||
ChangeNotifierProvider<PlaylistService>.value(value: _playlists),
|
||
ChangeNotifierProvider<OfflineMode>.value(value: _offlineMode),
|
||
ChangeNotifierProvider<CategoryService>.value(value: _categories),
|
||
ChangeNotifierProvider<AppSettings>.value(value: _settings),
|
||
ChangeNotifierProvider<AudioEffects>.value(value: _effects),
|
||
ChangeNotifierProvider<BakaAuth>.value(value: _bakaAuth),
|
||
ChangeNotifierProvider<YtDownloadService>.value(value: _ytDownload),
|
||
ChangeNotifierProvider<YtSearchService>.value(value: _ytSearch),
|
||
ChangeNotifierProvider<SyncService>.value(value: _sync),
|
||
ChangeNotifierProvider<DownloadService>.value(value: _downloads),
|
||
],
|
||
child: MaterialApp(
|
||
title: 'Melo',
|
||
debugShowCheckedModeBanner: false,
|
||
theme: MeloTheme.dark,
|
||
home: const HomeShell(),
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
class HomeShell extends StatefulWidget {
|
||
const HomeShell({super.key});
|
||
|
||
@override
|
||
State<HomeShell> createState() => _HomeShellState();
|
||
}
|
||
|
||
class _HomeShellState extends State<HomeShell>
|
||
with WidgetsBindingObserver, TickerProviderStateMixin {
|
||
int _index = 0;
|
||
late final AutoScan _autoScan;
|
||
late final PlayerExpansionController _expansion;
|
||
|
||
/// Adresse aus einem „Teilen"-Aufruf, die der Downloader übernehmen soll.
|
||
String? _geteilteAdresse;
|
||
|
||
void _goTo(int index) => setState(() => _index = index);
|
||
|
||
@override
|
||
void initState() {
|
||
super.initState();
|
||
_expansion = PlayerExpansionController(vsync: this);
|
||
final db = context.read<MeloDb>();
|
||
final lib = context.read<LibraryService>();
|
||
_autoScan = AutoScan(
|
||
geraeteAnzahl: countAndroidMediaStoreSongs,
|
||
bekannteAnzahl: db.countSongs,
|
||
scanne: lib.rescan,
|
||
);
|
||
WidgetsBinding.instance.addObserver(this);
|
||
// Beim Start einmal mit dem Server abgleichen — neue Titel von anderen
|
||
// Geräten sind dann sofort da.
|
||
context.read<SyncService>().automatisch();
|
||
unawaited(context.read<LibraryService>().ensureStartupPermissions());
|
||
unawaited(_pruefeGeteilteAdresse());
|
||
}
|
||
|
||
/// Sieht nach, ob die App über „Teilen" mit einer Adresse geöffnet wurde,
|
||
/// und wechselt dann in den Download-Bereich.
|
||
Future<void> _pruefeGeteilteAdresse() async {
|
||
final adresse = await const GeteilteAdresse().abholen();
|
||
if (adresse == null || !mounted) return;
|
||
setState(() {
|
||
_geteilteAdresse = adresse;
|
||
_index = 2;
|
||
});
|
||
}
|
||
|
||
@override
|
||
void dispose() {
|
||
_expansion.dispose();
|
||
WidgetsBinding.instance.removeObserver(this);
|
||
super.dispose();
|
||
}
|
||
|
||
@override
|
||
void didChangeAppLifecycleState(AppLifecycleState state) {
|
||
// Zurück in der App: nachsehen, ob inzwischen Musik dazugekommen ist —
|
||
// auf dem Gerät wie am Server.
|
||
if (state == AppLifecycleState.resumed) {
|
||
if (Platform.isAndroid) _autoScan.pruefe();
|
||
context.read<SyncService>().automatisch();
|
||
// Ein zweites Teilen startet die App nicht neu (singleTop), sondern
|
||
// bringt sie nur nach vorn — deshalb auch hier nachsehen.
|
||
unawaited(_pruefeGeteilteAdresse());
|
||
}
|
||
}
|
||
|
||
@override
|
||
Widget build(BuildContext context) {
|
||
final tabs = <Widget>[
|
||
MyMusicScreen(
|
||
onSearchTap: () => _goTo(1),
|
||
onFavoritesTap: () => _goTo(3),
|
||
),
|
||
const SearchScreen(),
|
||
DownloadsScreen(
|
||
adresse: _geteilteAdresse,
|
||
onAdresseUebernommen: () => setState(() => _geteilteAdresse = null),
|
||
),
|
||
const FavoritesScreen(),
|
||
const YoutubeSearchScreen(),
|
||
];
|
||
return ChangeNotifierProvider<PlayerExpansionController>.value(
|
||
value: _expansion,
|
||
// Consumer NUR um PopScope — sein `child:` (der Scaffold-Rumpf) wird
|
||
// laut Flutter-Semantik bei jedem _expansion-Tick NICHT neu gebaut,
|
||
// das ist hier auch nicht nötig: PopScope selbst braucht nur einen
|
||
// aktuellen Wert bei jedem HomeShell-Rebuild (z.B. Zurück-Taste
|
||
// gedrückt), keine Frame-genaue Aktualisierung während des Ziehens.
|
||
// Der Blur-Layer/Mini-Player-Fade in Task 4 braucht dagegen echte
|
||
// Live-Reaktivität und bekommt dafür einen eigenen, davon unabhängigen
|
||
// AnimatedBuilder direkt an seiner Stelle im Stack — siehe
|
||
// Reaktivitäts-Regel in Global Constraints.
|
||
child: Consumer<PlayerExpansionController>(
|
||
builder: (context, expansion, child) => PopScope(
|
||
// Offener/halb gezogener Player hat Vorrang vor dem Tab-Reset:
|
||
// Zurück soll ihn zuerst schließen, nicht gleichzeitig auch noch
|
||
// den Tab wechseln.
|
||
canPop: expansion.progress == 0 && _index == 0,
|
||
onPopInvokedWithResult: (didPop, _) {
|
||
if (didPop) return;
|
||
if (expansion.progress > 0) {
|
||
expansion.close(context);
|
||
} else {
|
||
setState(() => _index = 0);
|
||
}
|
||
},
|
||
child: child!,
|
||
),
|
||
child: Scaffold(
|
||
extendBody: true, // NowPlayingScreen (Task 5) braucht die volle Höhe bis unter die BottomNavigationBar
|
||
body: Stack(
|
||
children: [
|
||
AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) => IgnorePointer(
|
||
ignoring: _expansion.progress > 0,
|
||
child: ExcludeSemantics(
|
||
excluding: _expansion.progress > 0,
|
||
child: child,
|
||
),
|
||
),
|
||
child: Column(
|
||
children: [
|
||
Expanded(child: IndexedStack(index: _index, children: tabs)),
|
||
const SizedBox(height: MiniPlayer.hoehe), // Platz für den Overlay-Mini-Player
|
||
],
|
||
),
|
||
),
|
||
AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) {
|
||
final p = _expansion.progress;
|
||
if (p == 0) return const SizedBox.shrink();
|
||
return Positioned.fill(
|
||
child: BackdropFilter(
|
||
filter: ImageFilter.blur(sigmaX: p * 20.0, sigmaY: p * 20.0),
|
||
child: Container(color: Colors.transparent),
|
||
),
|
||
);
|
||
},
|
||
),
|
||
AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) => Positioned(
|
||
left: 0,
|
||
right: 0,
|
||
bottom: 0,
|
||
child: Opacity(
|
||
opacity: (1 - _expansion.progress).clamp(0.0, 1.0),
|
||
child: IgnorePointer(
|
||
ignoring: _expansion.progress > 0,
|
||
child: child,
|
||
),
|
||
),
|
||
),
|
||
child: const MiniPlayer(),
|
||
),
|
||
AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) {
|
||
final p = _expansion.progress;
|
||
return Positioned.fromRect(
|
||
rect: Rect.lerp(_miniRect(context), _vollbildRect(context), p)!,
|
||
child: Visibility(
|
||
visible: p > 0,
|
||
maintainState: true, // _CoverGrundState bleibt erhalten, siehe Spec
|
||
maintainAnimation: true,
|
||
child: Opacity(
|
||
// Detail-Inhalt blendet erst ab p > 0.3 ein, siehe Spec.
|
||
opacity: ((p - 0.3) / 0.7).clamp(0.0, 1.0),
|
||
child: child,
|
||
),
|
||
),
|
||
);
|
||
},
|
||
child: const NowPlayingScreen(),
|
||
),
|
||
StreamBuilder<MediaItem?>(
|
||
stream: context.read<MeloAudioHandler>().mediaItem,
|
||
builder: (context, snapshot) {
|
||
final item = snapshot.data;
|
||
if (item == null) return const SizedBox.shrink();
|
||
return AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) => WanderndesCover(
|
||
progress: _expansion.progress,
|
||
artUri: item.artUri,
|
||
miniRect: _miniCoverRect(context),
|
||
vollbildRect: _vollbildCoverRect(context),
|
||
),
|
||
);
|
||
},
|
||
),
|
||
],
|
||
),
|
||
// Haarlinie darüber: ohne sie geht die Leiste auf schwarzem Grund
|
||
// optisch im Inhalt auf und wirkt nicht wie ein Hauptmenü.
|
||
bottomNavigationBar: AnimatedBuilder(
|
||
animation: _expansion,
|
||
builder: (context, child) => Opacity(
|
||
opacity: (1 - _expansion.progress).clamp(0.0, 1.0),
|
||
child: IgnorePointer(
|
||
ignoring: _expansion.progress > 0,
|
||
child: child,
|
||
),
|
||
),
|
||
child: DecoratedBox(
|
||
decoration: const BoxDecoration(
|
||
border: Border(top: BorderSide(color: MeloTheme.border)),
|
||
),
|
||
child: BottomNavigationBar(
|
||
currentIndex: _index,
|
||
onTap: _goTo,
|
||
items: const [
|
||
BottomNavigationBarItem(
|
||
icon: Icon(Icons.headphones), label: 'Meine Musik'),
|
||
BottomNavigationBarItem(icon: Icon(Icons.search), label: 'Suchen'),
|
||
BottomNavigationBarItem(
|
||
icon: Icon(Icons.download_outlined),
|
||
activeIcon: Icon(Icons.download),
|
||
label: 'Download'),
|
||
BottomNavigationBarItem(
|
||
icon: Icon(Icons.favorite_border),
|
||
activeIcon: Icon(Icons.favorite),
|
||
label: 'Favoriten'),
|
||
BottomNavigationBarItem(
|
||
icon: Icon(Icons.smart_display_outlined),
|
||
activeIcon: Icon(Icons.smart_display),
|
||
label: 'YT-Suche'),
|
||
],
|
||
),
|
||
),
|
||
),
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
Rect _miniRect(BuildContext context) {
|
||
final size = MediaQuery.sizeOf(context);
|
||
final unten = size.height - MiniPlayer.hoehe - kBottomNavigationBarHeight;
|
||
return Rect.fromLTWH(0, unten, size.width, MiniPlayer.hoehe);
|
||
}
|
||
|
||
Rect _vollbildRect(BuildContext context) => Offset.zero & MediaQuery.sizeOf(context);
|
||
|
||
/// Feste 52×52-Größe, linksbündig mit MeloSpace.md-Abstand, vertikal
|
||
/// mittig in MiniPlayer.hoehe — Werte aus mini_player.dart übernommen
|
||
/// (dortiges Cover entfällt, siehe Task 6 Step 5).
|
||
Rect _miniCoverRect(BuildContext context) {
|
||
final mini = _miniRect(context);
|
||
const seite = 52.0;
|
||
final top = mini.top + (MiniPlayer.hoehe - seite) / 2;
|
||
return Rect.fromLTWH(mini.left + MeloSpace.md, top, seite, seite);
|
||
}
|
||
|
||
/// Nicht per Formel bestimmbar (Review-Panel-Fund): `_CoverPlatzhalter`
|
||
/// sitzt in NowPlayingScreens eigenem responsivem LayoutBuilder — die
|
||
/// tatsächliche Position wird stattdessen gemessen, siehe
|
||
/// coverPlatzhalterKey.
|
||
Rect _vollbildCoverRect(BuildContext context) {
|
||
final box = coverPlatzhalterKey.currentContext?.findRenderObject() as RenderBox?;
|
||
if (box == null || !box.hasSize) {
|
||
// Vor dem ersten Layout (z.B. ganz am Anfang, progress noch 0) —
|
||
// Notlösung: Platzhalter mittig im Vollbild-Rechteck annehmen, bis
|
||
// der erste Frame mit progress > 0 eine echte Messung liefert.
|
||
final voll = _vollbildRect(context);
|
||
final seite = voll.width - 48;
|
||
return Rect.fromLTWH(voll.left + 24, voll.top + 80, seite, seite);
|
||
}
|
||
return box.localToGlobal(Offset.zero) & box.size;
|
||
}
|
||
}
|