empathicqubit/mucke
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upgrade Flutter and dependencies; moor -> drift

Browse source
This commit is contained in:
Moritz Weber 2023-02-18 10:40:06 +01:00
parent faf306a291
commit 043c9d9d9f
40 changed files with 2888 additions and 2771 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CHANGELOG.md Normal file
View file

@ -0,0 +1,3 @@
## Unreleased Changes
- Upgrade to Flutter 3.7 & dependency updates

2
src/.flutter

@ -1 +1 @@
Subproject commit b8f7f1f9869bb2d116aa6a70dbeac61000b52849
Subproject commit 9944297138845a94256f1cf37beb88ff9a8e811a

3
src/build.yaml
View file

@ -1,6 +1,3 @@
targets:
$default:
builders:
drift_dev:
options:
generate_connect_constructor: true

18
src/lib/injection_container.dart
View file

@ -1,7 +1,6 @@
import 'package:audio_service/audio_service.dart';
import 'package:get_it/get_it.dart';
import 'package:just_audio/just_audio.dart';
import 'package:mucke/domain/usecases/play_album_from_index.dart';
import 'package:on_audio_query/on_audio_query.dart';
import 'domain/actors/audio_player_actor.dart';
@ -26,6 +25,7 @@ import 'domain/repositories/persistent_state_repository.dart';
import 'domain/repositories/platform_integration_repository.dart';
import 'domain/repositories/settings_repository.dart';
import 'domain/usecases/play_album.dart';
import 'domain/usecases/play_album_from_index.dart';
import 'domain/usecases/play_artist.dart';
import 'domain/usecases/play_playable.dart';
import 'domain/usecases/play_playlist.dart';
@ -55,11 +55,11 @@ import 'presentation/state/smart_list_page_store.dart';
import 'presentation/state/song_store.dart';
import 'system/datasources/audio_player_data_source.dart';
import 'system/datasources/audio_player_data_source_impl.dart';
import 'system/datasources/drift_database.dart';
import 'system/datasources/history_data_source.dart';
import 'system/datasources/home_widget_data_source.dart';
import 'system/datasources/local_music_fetcher.dart';
import 'system/datasources/local_music_fetcher_impl.dart';
import 'system/datasources/moor_database.dart';
import 'system/datasources/music_data_source_contract.dart';
import 'system/datasources/persistent_state_data_source.dart';
import 'system/datasources/platform_integration_data_source.dart';
@ -314,13 +314,13 @@ Future<void> setupGetIt() async {
);
// data sources
final MoorDatabase moorDatabase = MoorDatabase();
getIt.registerLazySingleton<MusicDataSource>(() => moorDatabase.musicDataDao);
getIt.registerLazySingleton<PersistentStateDataSource>(() => moorDatabase.persistentStateDao);
getIt.registerLazySingleton<SettingsDataSource>(() => moorDatabase.settingsDao);
getIt.registerLazySingleton<PlaylistDataSource>(() => moorDatabase.playlistDao);
getIt.registerLazySingleton<HomeWidgetDataSource>(() => moorDatabase.homeWidgetDao);
getIt.registerLazySingleton<HistoryDataSource>(() => moorDatabase.historyDao);
final MainDatabase driftDatabase = MainDatabase();
getIt.registerLazySingleton<MusicDataSource>(() => driftDatabase.musicDataDao);
getIt.registerLazySingleton<PersistentStateDataSource>(() => driftDatabase.persistentStateDao);
getIt.registerLazySingleton<SettingsDataSource>(() => driftDatabase.settingsDao);
getIt.registerLazySingleton<PlaylistDataSource>(() => driftDatabase.playlistDao);
getIt.registerLazySingleton<HomeWidgetDataSource>(() => driftDatabase.homeWidgetDao);
getIt.registerLazySingleton<HistoryDataSource>(() => driftDatabase.historyDao);
getIt.registerLazySingleton<LocalMusicFetcher>(
() => LocalMusicFetcherImpl(
getIt(),

2
src/lib/presentation/pages/playlist_page.dart
View file

@ -176,7 +176,7 @@ class _PlaylistPageState extends State<PlaylistPage> {
style: ElevatedButton.styleFrom(
shape: const StadiumBorder(),
padding: const EdgeInsets.symmetric(horizontal: 12.0),
primary: Colors.white10,
backgroundColor: Colors.white10,
shadowColor: Colors.transparent,
),
),

2
src/lib/presentation/pages/playlists_page.dart
View file

@ -108,7 +108,7 @@ class _PlaylistsPageState extends State<PlaylistsPage> with AutomaticKeepAliveCl
),
elevation: 8.0,
isOpenOnStart: false,
animationSpeed: 200,
animationDuration: const Duration(milliseconds: 200),
spacing: 4.0,
spaceBetweenChildren: 4.0,
useRotationAnimation: true,

3
src/lib/presentation/state/smart_list_form_store.dart
View file

@ -346,8 +346,6 @@ int _shuffleModeIndex(ShuffleMode? shuffleMode) {
ShuffleMode? _intToShuffleMode(int index) {
switch (index) {
case 0:
return null;
case 1:
return ShuffleMode.none;
case 2:
@ -355,4 +353,5 @@ ShuffleMode? _intToShuffleMode(int index) {
case 3:
return ShuffleMode.plus;
}
return null;
}

13
src/lib/presentation/theming.dart
View file

@ -33,7 +33,6 @@ ThemeData theme() => ThemeData(
highlightColor: LIGHT1,
scaffoldBackgroundColor: DARK2,
cardColor: DARK3,
toggleableActiveColor: LIGHT1,
elevatedButtonTheme: ElevatedButtonThemeData(
style: ElevatedButton.styleFrom(
backgroundColor: LIGHT1,
@ -47,32 +46,32 @@ ThemeData theme() => ThemeData(
),
// https://api.flutter.dev/flutter/material/TextTheme-class.html
textTheme: const TextTheme(
headline1: TextStyle(
displayLarge: TextStyle(
fontSize: 28.0,
fontWeight: FontWeight.w900,
color: LIGHT1,
),
headline2: TextStyle(
displayMedium: TextStyle(
fontSize: 24.0,
fontWeight: FontWeight.w900,
color: Colors.white,
),
headline3: TextStyle(
displaySmall: TextStyle(
fontSize: 20.0,
fontWeight: FontWeight.w900,
color: Colors.white,
),
headline4: TextStyle(
headlineMedium: TextStyle(
fontSize: 18.0,
fontWeight: FontWeight.w600,
color: Colors.white,
),
headline5: TextStyle(
headlineSmall: TextStyle(
fontSize: 18.0,
fontWeight: FontWeight.w400,
color: Colors.white70,
),
headline6: TextStyle(fontSize: 18.0),
titleLarge: TextStyle(fontSize: 18.0),
),
textSelectionTheme: const TextSelectionThemeData(
cursorColor: LIGHT2,

2
src/lib/presentation/widgets/artist_header.dart
View file

@ -36,7 +36,7 @@ class ArtistHeader extends StatelessWidget {
height: height * 0.66,
child: Text(
artist.name,
style: Theme.of(context).textTheme.headline1?.copyWith(
style: Theme.of(context).textTheme.displayLarge?.copyWith(
fontWeight: FontWeight.bold,
fontSize: 24.0,
color: Colors.white,

2
src/lib/presentation/widgets/highlight_album.dart
View file

@ -74,7 +74,7 @@ class HighlightAlbum extends StatelessWidget {
Container(height: 6.0),
Text(
album.title,
style: Theme.of(context).textTheme.headline4,
style: Theme.of(context).textTheme.headlineMedium,
maxLines: 2,
overflow: TextOverflow.ellipsis,
),

2
src/lib/presentation/widgets/highlight_artist.dart
View file

@ -66,7 +66,7 @@ class HighlightArtist extends StatelessWidget {
Container(height: 6.0),
Text(
artist.name,
style: Theme.of(context).textTheme.headline4,
style: Theme.of(context).textTheme.headlineMedium,
maxLines: 2,
overflow: TextOverflow.ellipsis,
),

30
src/lib/system/datasources/moor/history_dao.dart → src/lib/system/datasources/drift/history_dao.dart
View file

@ -7,15 +7,15 @@ import '../../models/history_entry_model.dart';
import '../../models/playlist_model.dart';
import '../../models/smart_list_model.dart';
import '../history_data_source.dart';
import '../moor_database.dart';
import '../drift_database.dart';
part 'history_dao.g.dart';
@DriftAccessor(tables: [HistoryEntries, Albums, Artists, Playlists, SmartLists, SmartListArtists])
class HistoryDao extends DatabaseAccessor<MoorDatabase>
class HistoryDao extends DatabaseAccessor<MainDatabase>
with _$HistoryDaoMixin
implements HistoryDataSource {
HistoryDao(MoorDatabase attachedDatabase) : super(attachedDatabase);
HistoryDao(MainDatabase attachedDatabase) : super(attachedDatabase);
@override
Future<void> addHistoryEntry(Playable playable) async {
@ -31,10 +31,10 @@ class HistoryDao extends DatabaseAccessor<MoorDatabase>
Stream<List<HistoryEntryModel>> historyStream({int? limit, required bool unique, required bool includeSearch}) {
// <- make a function out of this? for limit and sorting options?
final query = select(historyEntries).join([
leftOuterJoin(playlists, playlists.id.cast<String?>().equalsExp(historyEntries.identifier)),
leftOuterJoin(albums, albums.id.cast<String?>().equalsExp(historyEntries.identifier)),
leftOuterJoin(artists, artists.id.cast<String?>().equalsExp(historyEntries.identifier)),
leftOuterJoin(smartLists, smartLists.id.cast<String?>().equalsExp(historyEntries.identifier)),
leftOuterJoin(playlists, playlists.id.cast<String>().equalsExp(historyEntries.identifier)),
leftOuterJoin(albums, albums.id.cast<String>().equalsExp(historyEntries.identifier)),
leftOuterJoin(artists, artists.id.cast<String>().equalsExp(historyEntries.identifier)),
leftOuterJoin(smartLists, smartLists.id.cast<String>().equalsExp(historyEntries.identifier)),
]);
if (!includeSearch) {
@ -58,24 +58,24 @@ class HistoryDao extends DatabaseAccessor<MoorDatabase>
switch (etype) {
case PlayableType.album:
return HistoryEntryModel.fromMoor(entry, AlbumModel.fromMoor(e.readTable(albums)));
return HistoryEntryModel.fromDrift(entry, AlbumModel.fromDrift(e.readTable(albums)));
case PlayableType.artist:
return HistoryEntryModel.fromMoor(entry, ArtistModel.fromMoor(e.readTable(artists)));
return HistoryEntryModel.fromDrift(entry, ArtistModel.fromDrift(e.readTable(artists)));
case PlayableType.playlist:
return HistoryEntryModel.fromMoor(
entry, PlaylistModel.fromMoor(e.readTable(playlists)));
return HistoryEntryModel.fromDrift(
entry, PlaylistModel.fromDrift(e.readTable(playlists)));
case PlayableType.smartlist:
return HistoryEntryModel.fromMoor(
return HistoryEntryModel.fromDrift(
entry,
SmartListModel.fromMoor(
SmartListModel.fromDrift(
e.readTable(smartLists),
null, // TODO: how do we open a SmartListPage with an incomplete SmartListModel?
),
);
case PlayableType.search:
return HistoryEntryModel.fromMoor(entry, SearchQuery(entry.identifier));
return HistoryEntryModel.fromDrift(entry, SearchQuery(entry.identifier));
default:
return HistoryEntryModel.fromMoor(entry, SearchQuery('Something went wrong here!'));
return HistoryEntryModel.fromDrift(entry, SearchQuery('Something went wrong here!'));
}
}).toList());
}

7
src/lib/system/datasources/moor/history_dao.g.dart → src/lib/system/datasources/drift/history_dao.g.dart
View file

@ -2,11 +2,8 @@
part of 'history_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$HistoryDaoMixin on DatabaseAccessor<MoorDatabase> {
// ignore_for_file: type=lint
mixin _$HistoryDaoMixin on DatabaseAccessor<MainDatabase> {
$HistoryEntriesTable get historyEntries => attachedDatabase.historyEntries;
$AlbumsTable get albums => attachedDatabase.albums;
$ArtistsTable get artists => attachedDatabase.artists;

24
src/lib/system/datasources/moor/home_widget_dao.dart → src/lib/system/datasources/drift/home_widget_dao.dart
View file

@ -8,15 +8,15 @@ import '../../models/home_widgets/home_widget_model.dart';
import '../../models/home_widgets/playlists_model.dart';
import '../../models/home_widgets/shuffle_all_model.dart';
import '../home_widget_data_source.dart';
import '../moor_database.dart';
import '../drift_database.dart';
part 'home_widget_dao.g.dart';
@DriftAccessor(tables: [HomeWidgets, KeyValueEntries])
class HomeWidgetDao extends DatabaseAccessor<MoorDatabase>
class HomeWidgetDao extends DatabaseAccessor<MainDatabase>
with _$HomeWidgetDaoMixin
implements HomeWidgetDataSource {
HomeWidgetDao(MoorDatabase db) : super(db);
HomeWidgetDao(MainDatabase db) : super(db);
@override
Stream<List<HomeWidgetModel>> get homeWidgetsStream {
@ -27,7 +27,7 @@ class HomeWidgetDao extends DatabaseAccessor<MoorDatabase>
@override
Future<void> insertHomeWidget(HomeWidgetModel homeWidget) async {
into(homeWidgets).insert(homeWidget.toMoor());
into(homeWidgets).insert(homeWidget.toDrift());
}
@override
@ -70,23 +70,23 @@ class HomeWidgetDao extends DatabaseAccessor<MoorDatabase>
@override
Future<void> updateHomeWidget(HomeWidgetModel homeWidget) async {
await (update(homeWidgets)..where((tbl) => tbl.position.equals(homeWidget.position)))
.write(homeWidget.toMoor());
.write(homeWidget.toDrift());
}
HomeWidgetModel _getHomeWidget(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
HomeWidgetModel _getHomeWidget(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
switch (type) {
case HomeWidgetType.shuffle_all:
return HomeShuffleAllModel.fromMoor(moorHomeWidget);
return HomeShuffleAllModel.fromDrift(driftHomeWidget);
case HomeWidgetType.album_of_day:
return HomeAlbumOfDayModel.fromMoor(moorHomeWidget);
return HomeAlbumOfDayModel.fromDrift(driftHomeWidget);
case HomeWidgetType.artist_of_day:
return HomeArtistOfDayModel.fromMoor(moorHomeWidget);
return HomeArtistOfDayModel.fromDrift(driftHomeWidget);
case HomeWidgetType.playlists:
return HomePlaylistsModel.fromMoor(moorHomeWidget);
return HomePlaylistsModel.fromDrift(driftHomeWidget);
case HomeWidgetType.history:
return HomeHistoryModel.fromMoor(moorHomeWidget);
return HomeHistoryModel.fromDrift(driftHomeWidget);
}
}
}

9
src/lib/system/datasources/drift/home_widget_dao.g.dart Normal file
View file

@ -0,0 +1,9 @@
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'home_widget_dao.dart';
// ignore_for_file: type=lint
mixin _$HomeWidgetDaoMixin on DatabaseAccessor<MainDatabase> {
$HomeWidgetsTable get homeWidgets => attachedDatabase.homeWidgets;
$KeyValueEntriesTable get keyValueEntries => attachedDatabase.keyValueEntries;
}

164
src/lib/system/datasources/moor/music_data_dao.dart → src/lib/system/datasources/drift/music_data_dao.dart
View file

@ -8,7 +8,7 @@ import '../../../domain/entities/playable.dart';
import '../../models/album_model.dart';
import '../../models/artist_model.dart';
import '../../models/song_model.dart';
import '../moor_database.dart';
import '../drift_database.dart';
import '../music_data_source_contract.dart';
part 'music_data_dao.g.dart';
@ -24,29 +24,36 @@ part 'music_data_dao.g.dart';
HistoryEntries,
SmartListArtists
])
class MusicDataDao extends DatabaseAccessor<MoorDatabase>
class MusicDataDao extends DatabaseAccessor<MainDatabase>
with _$MusicDataDaoMixin
implements MusicDataSource {
MusicDataDao(MoorDatabase db) : super(db);
MusicDataDao(MainDatabase db) : super(db);
@override
Stream<List<SongModel>> get songStream {
return (select(songs)..orderBy([(t) => OrderingTerm(expression: t.title)])).watch().map(
(moorSongList) => moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList());
return (select(songs)..orderBy([(t) => OrderingTerm(expression: t.title)]))
.watch()
.map((driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList());
}
@override
Stream<List<AlbumModel>> get albumStream {
return (select(albums)..orderBy([(t) => OrderingTerm(expression: t.title)])).watch().map(
(moorAlbumList) =>
moorAlbumList.map((moorAlbum) => AlbumModel.fromMoor(moorAlbum)).toList());
return (select(albums)..orderBy([(t) => OrderingTerm(expression: t.title)]))
.watch()
.map((driftAlbumList) => driftAlbumList
.map((driftAlbum) => AlbumModel.fromDrift(driftAlbum))
.toList());
}
@override
Stream<List<ArtistModel>> get artistStream {
return (select(artists)..orderBy([(t) => OrderingTerm(expression: t.name)])).watch().map(
(moorArtistList) =>
moorArtistList.map((moorArtist) => ArtistModel.fromMoor(moorArtist)).toList());
return (select(artists)..orderBy([(t) => OrderingTerm(expression: t.name)]))
.watch()
.map((driftArtistList) => driftArtistList
.map((driftArtist) => ArtistModel.fromDrift(driftArtist))
.toList());
}
@override
@ -59,8 +66,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
]))
.watch()
.distinct(const ListEquality().equals)
.map((moorSongList) =>
moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList());
.map((driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList());
}
@override
@ -72,8 +80,10 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
]))
.watch()
.distinct(const ListEquality().equals)
.map((moorAlbumList) {
return moorAlbumList.map((moorAlbum) => AlbumModel.fromMoor(moorAlbum)).toList();
.map((driftAlbumList) {
return driftAlbumList
.map((driftAlbum) => AlbumModel.fromDrift(driftAlbum))
.toList();
});
}
@ -85,14 +95,18 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
.watch()
.distinct(const ListEquality().equals)
.map(
(moorSongList) => moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList(),
(driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList(),
);
}
@override
Future<SongModel?> getSongByPath(String path) async {
return (select(songs)..where((t) => t.path.equals(path))).getSingleOrNull().then(
(moorSong) => moorSong == null ? null : SongModel.fromMoor(moorSong),
return (select(songs)..where((t) => t.path.equals(path)))
.getSingleOrNull()
.then(
(driftSong) => driftSong == null ? null : SongModel.fromDrift(driftSong),
);
}
@ -116,13 +130,17 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
await batch((batch) {
batch.insertAllOnConflictUpdate(
songs,
songModels.map((e) => e.toMoorInsert()).toList(),
songModels.map((e) => e.toDriftInsert()).toList(),
);
});
});
deletedSongs.addAll(await (select(songs)..where((tbl) => tbl.present.equals(false))).get().then(
(moorSongList) => moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList()));
deletedSongs.addAll(await (select(songs)
..where((tbl) => tbl.present.equals(false)))
.get()
.then((driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList()));
await (delete(songs)..where((tbl) => tbl.present.equals(false))).go();
@ -169,8 +187,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
(t) => OrderingTerm(expression: t.trackNumber)
]))
.get()
.then((moorSongList) =>
moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList());
.then((driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList());
SongModel? prevSong;
for (final s in albumSongs) {
@ -191,8 +210,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
(t) => OrderingTerm(expression: t.trackNumber)
]))
.get()
.then((moorSongList) =>
moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList());
.then((driftSongList) => driftSongList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList());
bool current = false;
SongModel? nextSong;
@ -211,13 +231,15 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
@override
Future<void> updateSongs(List<SongModel> songModels) async {
await batch((batch) {
batch.replaceAll(songs, songModels.map((e) => e.toSongsCompanion()).toList());
batch.replaceAll(
songs, songModels.map((e) => e.toSongsCompanion()).toList());
});
}
@override
Future<AlbumOfDay?> getAlbumOfDay() async {
final value = await (select(keyValueEntries)..where((tbl) => tbl.key.equals(ALBUM_OF_DAY)))
final value = await (select(keyValueEntries)
..where((tbl) => tbl.key.equals(ALBUM_OF_DAY)))
.getSingleOrNull()
.then((entry) => entry?.value);
@ -230,13 +252,15 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
final int id = dict['id'] as int;
final int millisecondsSinceEpoch = dict['date'] as int;
final AlbumModel? album = await (select(albums)..where((tbl) => tbl.id.equals(id)))
final AlbumModel? album = await (select(albums)
..where((tbl) => tbl.id.equals(id)))
.getSingleOrNull()
.then((value) => value == null ? null : AlbumModel.fromMoor(value));
.then((value) => value == null ? null : AlbumModel.fromDrift(value));
if (album == null) return null;
return AlbumOfDay(album, DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch));
return AlbumOfDay(
album, DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch));
}
@override
@ -251,7 +275,8 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
@override
Future<ArtistOfDay?> getArtistOfDay() async {
final value = await (select(keyValueEntries)..where((tbl) => tbl.key.equals(ARTIST_OF_DAY)))
final value = await (select(keyValueEntries)
..where((tbl) => tbl.key.equals(ARTIST_OF_DAY)))
.getSingleOrNull()
.then((entry) => entry?.value);
@ -264,13 +289,15 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
final int id = dict['id'] as int;
final int millisecondsSinceEpoch = dict['date'] as int;
final ArtistModel? artist = await (select(artists)..where((tbl) => tbl.id.equals(id)))
final ArtistModel? artist = await (select(artists)
..where((tbl) => tbl.id.equals(id)))
.getSingleOrNull()
.then((value) => value == null ? null : ArtistModel.fromMoor(value));
.then((value) => value == null ? null : ArtistModel.fromDrift(value));
if (artist == null) return null;
return ArtistOfDay(artist, DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch));
return ArtistOfDay(
artist, DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch));
}
@override
@ -286,10 +313,13 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
@override
Future<List<AlbumModel>> searchAlbums(String searchText, {int? limit}) async {
final List<AlbumModel> result = await (select(albums)
..where((tbl) => tbl.title.regexp(searchText, dotAll: true, caseSensitive: false)))
..where((tbl) =>
tbl.title.regexp(searchText, dotAll: true, caseSensitive: false)))
.get()
.then(
(moorList) => moorList.map((moorAlbum) => AlbumModel.fromMoor(moorAlbum)).toList(),
(driftList) => driftList
.map((driftAlbum) => AlbumModel.fromDrift(driftAlbum))
.toList(),
);
if (limit != null) {
@ -300,12 +330,16 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
}
@override
Future<List<ArtistModel>> searchArtists(String searchText, {int? limit}) async {
Future<List<ArtistModel>> searchArtists(String searchText,
{int? limit}) async {
final List<ArtistModel> result = await (select(artists)
..where((tbl) => tbl.name.regexp(searchText, dotAll: true, caseSensitive: false)))
..where((tbl) =>
tbl.name.regexp(searchText, dotAll: true, caseSensitive: false)))
.get()
.then(
(moorList) => moorList.map((moorArtist) => ArtistModel.fromMoor(moorArtist)).toList(),
(driftList) => driftList
.map((driftArtist) => ArtistModel.fromDrift(driftArtist))
.toList(),
);
if (limit != null) {
@ -318,10 +352,13 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
@override
Future<List<SongModel>> searchSongs(String searchText, {int? limit}) async {
final List<SongModel> result = await (select(songs)
..where((tbl) => tbl.title.regexp(searchText, dotAll: true, caseSensitive: false)))
..where((tbl) =>
tbl.title.regexp(searchText, dotAll: true, caseSensitive: false)))
.get()
.then(
(moorList) => moorList.map((moorSong) => SongModel.fromMoor(moorSong)).toList(),
(driftList) => driftList
.map((driftSong) => SongModel.fromDrift(driftSong))
.toList(),
);
if (limit != null) {
@ -333,8 +370,11 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
@override
Stream<SongModel> getSongStream(String path) {
return (select(songs)..where((t) => t.path.equals(path))).watchSingle().distinct().map(
(moorSong) => SongModel.fromMoor(moorSong),
return (select(songs)..where((t) => t.path.equals(path)))
.watchSingle()
.distinct()
.map(
(driftSong) => SongModel.fromDrift(driftSong),
);
}
@ -342,7 +382,10 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
Future<int?> getAlbumId(String? title, String? artist, int? year) {
return (select(albums)
..where(
(t) => t.artist.equals(artist) & t.title.equals(title) & t.year.equals(year),
(t) =>
t.artist.equalsNullable(artist) &
t.title.equalsNullable(title) &
t.year.equalsNullable(year),
))
.getSingleOrNull()
.then((v) => v?.id);
@ -366,7 +409,8 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
);
// delete songs
batch.deleteWhere<$SongsTable, dynamic>(songs, (tbl) => tbl.path.isIn(paths));
batch.deleteWhere<$SongsTable, dynamic>(
songs, (tbl) => tbl.path.isIn(paths));
});
// delete empty albums
@ -378,7 +422,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
// Delete empty albums and all their database appearances.
Future<void> _deleteAlbumIfEmpty(int albumId) async {
final aSongs = await (select(songs)..where((tbl) => tbl.albumId.equals(albumId))).get();
final aSongs = await (select(songs)
..where((tbl) => tbl.albumId.equals(albumId)))
.get();
if (aSongs.isEmpty) {
await (delete(albums)..where((tbl) => tbl.id.equals(albumId))).go();
// delete history entries with this album
@ -392,11 +438,15 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
// Delete empty artists and all their database appearances.
Future<void> _deleteArtistIfEmpty(String name) async {
final aAlbums = await (select(albums)..where((tbl) => tbl.artist.equals(name))).get();
final aAlbums =
await (select(albums)..where((tbl) => tbl.artist.equals(name))).get();
if (aAlbums.isEmpty) {
final emptyArtists = await (select(artists)..where((tbl) => tbl.name.equals(name))).get();
final emptyArtists =
await (select(artists)..where((tbl) => tbl.name.equals(name))).get();
await (delete(artists)..where((tbl) => tbl.name.equals(name))).go();
await (delete(smartListArtists)..where((tbl) => tbl.artistName.equals(name))).go();
await (delete(smartListArtists)
..where((tbl) => tbl.artistName.equals(name)))
.go();
for (final emptyArtist in emptyArtists) {
(delete(historyEntries)
@ -409,13 +459,15 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
}
@override
Stream<Set<String>> get blockedFilesStream =>
select(blockedFiles).watch().map((value) => value.map((e) => e.path).toSet());
Stream<Set<String>> get blockedFilesStream => select(blockedFiles)
.watch()
.map((value) => value.map((e) => e.path).toSet());
@override
Future<void> removeBlockedFiles(List<String> paths) async {
await batch((batch) {
batch.deleteWhere<$BlockedFilesTable, dynamic>(blockedFiles, (tbl) => tbl.path.isIn(paths));
batch.deleteWhere<$BlockedFilesTable, dynamic>(
blockedFiles, (tbl) => tbl.path.isIn(paths));
});
}
@ -428,7 +480,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
// delete history entries with missing album
for (final entry in albumHistoryEntries) {
if ((await (select(albums)..where((tbl) => tbl.id.equals(int.parse(entry.identifier)))).get())
if ((await (select(albums)
..where((tbl) => tbl.id.equals(int.parse(entry.identifier))))
.get())
.isEmpty) {
(delete(historyEntries)
..where((tbl) =>
@ -445,7 +499,9 @@ class MusicDataDao extends DatabaseAccessor<MoorDatabase>
// delete history entries with missing album
for (final entry in artistHistoryEntries) {
if ((await (select(artists)..where((tbl) => tbl.id.equals(int.parse(entry.identifier)))).get())
if ((await (select(artists)
..where((tbl) => tbl.id.equals(int.parse(entry.identifier))))
.get())
.isEmpty) {
(delete(historyEntries)
..where((tbl) =>

7
src/lib/system/datasources/moor/music_data_dao.g.dart → src/lib/system/datasources/drift/music_data_dao.g.dart
View file

@ -2,11 +2,8 @@
part of 'music_data_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$MusicDataDaoMixin on DatabaseAccessor<MoorDatabase> {
// ignore_for_file: type=lint
mixin _$MusicDataDaoMixin on DatabaseAccessor<MainDatabase> {
$AlbumsTable get albums => attachedDatabase.albums;
$ArtistsTable get artists => attachedDatabase.artists;
$SongsTable get songs => attachedDatabase.songs;

22
src/lib/system/datasources/moor/persistent_state_dao.dart → src/lib/system/datasources/drift/persistent_state_dao.dart
View file

@ -14,7 +14,7 @@ import '../../models/queue_item_model.dart';
import '../../models/shuffle_mode_model.dart';
import '../../models/smart_list_model.dart';
import '../../models/song_model.dart';
import '../moor_database.dart';
import '../drift_database.dart';
import '../persistent_state_data_source.dart';
part 'persistent_state_dao.g.dart';
@ -31,10 +31,10 @@ part 'persistent_state_dao.g.dart';
AvailableSongEntries,
KeyValueEntries,
])
class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
class PersistentStateDao extends DatabaseAccessor<MainDatabase>
with _$PersistentStateDaoMixin
implements PersistentStateDataSource {
PersistentStateDao(MoorDatabase db) : super(db);
PersistentStateDao(MainDatabase db) : super(db);
@override
Future<List<QueueItemModel>> get queueItems {
@ -43,7 +43,7 @@ class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
return query.get().then((rows) => rows.map((row) {
return QueueItemModel(
SongModel.fromMoor(row.readTable(songs)),
SongModel.fromDrift(row.readTable(songs)),
originalIndex: row.readTable(queueEntries).originalIndex,
source: row.readTable(queueEntries).type.toQueueItemType(),
isAvailable: row.readTable(queueEntries).isAvailable,
@ -53,7 +53,7 @@ class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
@override
Future<void> setQueueItems(List<QueueItemModel> queue) async {
final _queueEntries = <Insertable<MoorQueueEntry>>[];
final _queueEntries = <Insertable<DriftQueueEntry>>[];
for (var i = 0; i < queue.length; i++) {
_queueEntries.add(QueueEntriesCompanion(
@ -81,7 +81,7 @@ class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
return query.get().then((rows) => rows.map((row) {
return QueueItemModel(
SongModel.fromMoor(row.readTable(songs)),
SongModel.fromDrift(row.readTable(songs)),
originalIndex: row.readTable(availableSongEntries).originalIndex,
source: row.readTable(availableSongEntries).type.toQueueItemType(),
isAvailable: row.readTable(availableSongEntries).isAvailable,
@ -169,19 +169,19 @@ class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
result = await (select(albums)
..where((tbl) => tbl.id.equals(int.parse(data['id'] as String))))
.getSingleOrNull()
.then((value) => value == null ? null : AlbumModel.fromMoor(value));
.then((value) => value == null ? null : AlbumModel.fromDrift(value));
break;
case PlayableType.artist:
result = await (select(artists)..where((tbl) => tbl.name.equals(data['id'] as String)))
.getSingleOrNull()
.then((value) => value == null ? null : ArtistModel.fromMoor(value));
.then((value) => value == null ? null : ArtistModel.fromDrift(value));
break;
case PlayableType.playlist:
final plId = int.parse(data['id'] as String);
// TODO: need proper getter for this
final moorPl =
final driftPl =
await (select(playlists)..where((tbl) => tbl.id.equals(plId))).getSingleOrNull();
result = moorPl == null ? null : PlaylistModel.fromMoor(moorPl);
result = driftPl == null ? null : PlaylistModel.fromDrift(driftPl);
break;
case PlayableType.smartlist:
final slId = int.parse(data['id'] as String);
@ -196,7 +196,7 @@ class PersistentStateDao extends DatabaseAccessor<MoorDatabase>
[innerJoin(artists, artists.name.equalsExp(smartListArtists.artistName))],
)).map((p0) => p0.readTable(artists)).get();
result = SmartListModel.fromMoor(sl, slArtists);
result = SmartListModel.fromDrift(sl, slArtists);
}
break;
case PlayableType.search:

7
src/lib/system/datasources/moor/persistent_state_dao.g.dart → src/lib/system/datasources/drift/persistent_state_dao.g.dart
View file

@ -2,11 +2,8 @@
part of 'persistent_state_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$PersistentStateDaoMixin on DatabaseAccessor<MoorDatabase> {
// ignore_for_file: type=lint
mixin _$PersistentStateDaoMixin on DatabaseAccessor<MainDatabase> {
$AlbumsTable get albums => attachedDatabase.albums;
$ArtistsTable get artists => attachedDatabase.artists;
$SongsTable get songs => attachedDatabase.songs;

54
src/lib/system/datasources/moor/playlist_dao.dart → src/lib/system/datasources/drift/playlist_dao.dart
View file

@ -7,7 +7,7 @@ import '../../../domain/entities/smart_list.dart' as sl;
import '../../models/playlist_model.dart';
import '../../models/smart_list_model.dart';
import '../../models/song_model.dart';
import '../moor_database.dart';
import '../drift_database.dart';
import '../playlist_data_source.dart';
part 'playlist_dao.g.dart';
@ -22,10 +22,10 @@ part 'playlist_dao.g.dart';
SmartListArtists,
HistoryEntries
])
class PlaylistDao extends DatabaseAccessor<MoorDatabase>
class PlaylistDao extends DatabaseAccessor<MainDatabase>
with _$PlaylistDaoMixin
implements PlaylistDataSource {
PlaylistDao(MoorDatabase db) : super(db);
PlaylistDao(MainDatabase db) : super(db);
@override
Future<void> addSongsToPlaylist(PlaylistModel playlist, List<SongModel> songs) async {
@ -60,7 +60,7 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
..where((tbl) => tbl.id.equals(playlistId))
..limit(1))
.watchSingle()
.map((event) => PlaylistModel.fromMoor(event));
.map((event) => PlaylistModel.fromDrift(event));
}
@override
@ -84,7 +84,7 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
Stream<List<PlaylistModel>> get playlistsStream {
return select(playlists)
.watch()
.map((moorPlaylists) => moorPlaylists.map((e) => PlaylistModel.fromMoor(e)).toList());
.map((driftPlaylists) => driftPlaylists.map((e) => PlaylistModel.fromDrift(e)).toList());
}
@override
@ -94,8 +94,8 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
..orderBy([(t) => OrderingTerm.asc(t.position)]))
.join(
[innerJoin(songs, songs.path.equalsExp(playlistEntries.songPath))],
)).watch().map((moorSongList) =>
moorSongList.map((moorSong) => SongModel.fromMoor(moorSong.readTable(songs))).toList());
)).watch().map((driftSongList) =>
driftSongList.map((driftSong) => SongModel.fromDrift(driftSong.readTable(songs))).toList());
}
@override
@ -225,17 +225,17 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
[innerJoin(artists, artists.name.equalsExp(smartListArtists.artistName))],
)).watch();
return Rx.combineLatest2<List<MoorSmartList>, List<TypedResult>, List<SmartListModel>>(
return Rx.combineLatest2<List<DriftSmartList>, List<TypedResult>, List<SmartListModel>>(
slStream,
slArtistStream,
(a, b) {
return a.map((sl) {
print(sl);
final moorArtists =
final driftArtists =
(b.where((element) => element.readTable(smartListArtists).smartListId == sl.id))
.map((e) => e.readTable(artists))
.toList();
return SmartListModel.fromMoor(sl, moorArtists);
return SmartListModel.fromDrift(sl, driftArtists);
}).toList();
},
);
@ -253,12 +253,12 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
[innerJoin(artists, artists.name.equalsExp(smartListArtists.artistName))],
).watch();
return Rx.combineLatest2<MoorSmartList, List<TypedResult>, SmartListModel>(
return Rx.combineLatest2<DriftSmartList, List<TypedResult>, SmartListModel>(
slStream,
slArtistStream,
(a, b) {
final moorArtists = b.map((e) => e.readTable(artists)).toList();
return SmartListModel.fromMoor(a, moorArtists);
final driftArtists = b.map((e) => e.readTable(artists)).toList();
return SmartListModel.fromDrift(a, driftArtists);
},
);
}
@ -286,21 +286,21 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
@override
Stream<List<SongModel>> getSmartListSongStream(SmartListModel smartList) {
SimpleSelectStatement<$SongsTable, MoorSong> query = select(songs);
SimpleSelectStatement<$SongsTable, DriftSong> query = select(songs);
final filter = smartList.filter;
query = query..where((tbl) => tbl.likeCount.isBiggerOrEqualValue(filter.minLikeCount));
query = query..where((tbl) => tbl.likeCount.isSmallerOrEqualValue(filter.maxLikeCount));
if (filter.minPlayCount != null)
query = query..where((tbl) => tbl.playCount.isBiggerOrEqualValue(filter.minPlayCount));
query = query..where((tbl) => tbl.playCount.isBiggerOrEqualValue(filter.minPlayCount!));
if (filter.maxPlayCount != null)
query = query..where((tbl) => tbl.playCount.isSmallerOrEqualValue(filter.maxPlayCount));
query = query..where((tbl) => tbl.playCount.isSmallerOrEqualValue(filter.maxPlayCount!));
if (filter.minYear != null)
query = query..where((tbl) => tbl.year.isBiggerOrEqualValue(filter.minYear));
query = query..where((tbl) => tbl.year.isBiggerOrEqualValue(filter.minYear!));
if (filter.maxYear != null)
query = query..where((tbl) => tbl.year.isSmallerOrEqualValue(filter.maxYear));
query = query..where((tbl) => tbl.year.isSmallerOrEqualValue(filter.maxYear!));
query = query..where((tbl) => tbl.blockLevel.isSmallerOrEqualValue(filter.blockLevel));
@ -319,7 +319,7 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
query = query..orderBy(orderingTerms);
return query.watch().map(
(moorSongList) => moorSongList.map((moorSong) => SongModel.fromMoor(moorSong)).toList());
(driftSongList) => driftSongList.map((driftSong) => SongModel.fromDrift(driftSong)).toList());
}
@override
@ -328,8 +328,8 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
..where((tbl) => tbl.name.regexp(searchText, dotAll: true, caseSensitive: false)))
.get()
.then(
(moorList) =>
moorList.map((moorPlaylist) => PlaylistModel.fromMoor(moorPlaylist)).toList(),
(driftList) =>
driftList.map((driftPlaylist) => PlaylistModel.fromDrift(driftPlaylist)).toList(),
);
if (limit != null) {
@ -349,13 +349,13 @@ class PlaylistDao extends DatabaseAccessor<MoorDatabase>
..where((tbl) => tbl.name.regexp(searchText, dotAll: true, caseSensitive: false)))
.get()
.then(
(moorList) {
return moorList.map((moorSmartList) {
final moorArtists = (slArtists.where(
(element) => element.readTable(smartListArtists).smartListId == moorSmartList.id))
(driftList) {
return driftList.map((driftSmartList) {
final driftArtists = (slArtists.where(
(element) => element.readTable(smartListArtists).smartListId == driftSmartList.id))
.map((e) => e.readTable(artists))
.toList();
return SmartListModel.fromMoor(moorSmartList, moorArtists);
return SmartListModel.fromDrift(driftSmartList, driftArtists);
}).toList();
},
);
@ -423,7 +423,7 @@ List<OrderingTerm Function($SongsTable)> _generateOrderingTerms(sl.OrderBy order
int i = 0;
while (i < orderBy.orderCriteria.length) {
final OrderingMode mode = orderBy.orderDirections[i].toMoor();
final OrderingMode mode = orderBy.orderDirections[i].toDrift();
switch (orderBy.orderCriteria[i]) {
case sl.OrderCriterion.artistName:
orderingTerms.add(

7
src/lib/system/datasources/moor/playlist_dao.g.dart → src/lib/system/datasources/drift/playlist_dao.g.dart
View file

@ -2,11 +2,8 @@
part of 'playlist_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$PlaylistDaoMixin on DatabaseAccessor<MoorDatabase> {
// ignore_for_file: type=lint
mixin _$PlaylistDaoMixin on DatabaseAccessor<MainDatabase> {
$AlbumsTable get albums => attachedDatabase.albums;
$ArtistsTable get artists => attachedDatabase.artists;
$SongsTable get songs => attachedDatabase.songs;

6
src/lib/system/datasources/moor/settings_dao.dart → src/lib/system/datasources/drift/settings_dao.dart
View file

@ -1,16 +1,16 @@
import 'package:drift/drift.dart';
import '../../../constants.dart';
import '../moor_database.dart';
import '../drift_database.dart';
import '../settings_data_source.dart';
part 'settings_dao.g.dart';
@DriftAccessor(tables: [LibraryFolders, KeyValueEntries, BlockedFiles])
class SettingsDao extends DatabaseAccessor<MoorDatabase>
class SettingsDao extends DatabaseAccessor<MainDatabase>
with _$SettingsDaoMixin
implements SettingsDataSource {
SettingsDao(MoorDatabase attachedDatabase) : super(attachedDatabase);
SettingsDao(MainDatabase attachedDatabase) : super(attachedDatabase);
@override
Stream<List<String>> get libraryFoldersStream =>

7
src/lib/system/datasources/moor/settings_dao.g.dart → src/lib/system/datasources/drift/settings_dao.g.dart
View file

@ -2,11 +2,8 @@
part of 'settings_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$SettingsDaoMixin on DatabaseAccessor<MoorDatabase> {
// ignore_for_file: type=lint
mixin _$SettingsDaoMixin on DatabaseAccessor<MainDatabase> {
$LibraryFoldersTable get libraryFolders => attachedDatabase.libraryFolders;
$KeyValueEntriesTable get keyValueEntries => attachedDatabase.keyValueEntries;
$BlockedFilesTable get blockedFiles => attachedDatabase.blockedFiles;

90
src/lib/system/datasources/moor_database.dart → src/lib/system/datasources/drift_database.dart
View file

@ -1,9 +1,7 @@
import 'dart:convert';
import 'dart:io';
import 'dart:isolate';
import 'package:drift/drift.dart';
import 'package:drift/isolate.dart';
import 'package:drift/native.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';
@ -11,18 +9,18 @@ import 'package:path_provider/path_provider.dart';
import '../../constants.dart';
import '../../defaults.dart';
import '../../domain/entities/playable.dart';
import 'moor/history_dao.dart';
import 'moor/home_widget_dao.dart';
import 'moor/music_data_dao.dart';
import 'moor/persistent_state_dao.dart';
import 'moor/playlist_dao.dart';
import 'moor/settings_dao.dart';
import 'drift/history_dao.dart';
import 'drift/home_widget_dao.dart';
import 'drift/music_data_dao.dart';
import 'drift/persistent_state_dao.dart';
import 'drift/playlist_dao.dart';
import 'drift/settings_dao.dart';
part 'moor_database.g.dart';
part 'drift_database.g.dart';
const String MOOR_ISOLATE = 'MOOR_ISOLATE';
const String DRIFT_ISOLATE = 'DRIFT_ISOLATE';
@DataClassName('MoorArtist')
@DataClassName('DriftArtist')
class Artists extends Table {
TextColumn get name => text()();
IntColumn get id => integer()();
@ -31,7 +29,7 @@ class Artists extends Table {
Set<Column> get primaryKey => {id};
}
@DataClassName('MoorAlbum')
@DataClassName('DriftAlbum')
class Albums extends Table {
IntColumn get id => integer()();
TextColumn get title => text()();
@ -43,7 +41,7 @@ class Albums extends Table {
Set<Column> get primaryKey => {id};
}
@DataClassName('MoorSong')
@DataClassName('DriftSong')
class Songs extends Table {
TextColumn get title => text()();
TextColumn get albumTitle => text()();
@ -70,7 +68,7 @@ class Songs extends Table {
Set<Column> get primaryKey => {path};
}
@DataClassName('MoorQueueEntry')
@DataClassName('DriftQueueEntry')
class QueueEntries extends Table {
IntColumn get index => integer()();
TextColumn get path => text()();
@ -107,7 +105,7 @@ class LibraryFolders extends Table {
TextColumn get path => text()();
}
@DataClassName('MoorSmartList')
@DataClassName('DriftSmartList')
class SmartLists extends Table {
IntColumn get id => integer().autoIncrement()();
TextColumn get name => text()();
@ -137,13 +135,13 @@ class SmartLists extends Table {
TextColumn get orderDirections => text()();
}
@DataClassName('MoorSmartListArtist')
@DataClassName('DriftSmartListArtist')
class SmartListArtists extends Table {
IntColumn get smartListId => integer()();
TextColumn get artistName => text()();
}
@DataClassName('MoorPlaylist')
@DataClassName('DriftPlaylist')
class Playlists extends Table {
IntColumn get id => integer().autoIncrement()();
TextColumn get name => text()();
@ -156,14 +154,14 @@ class Playlists extends Table {
dateTime().withDefault(Constant(DateTime.fromMillisecondsSinceEpoch(0)))();
}
@DataClassName('MoorPlaylistEntry')
@DataClassName('DriftPlaylistEntry')
class PlaylistEntries extends Table {
IntColumn get playlistId => integer()();
TextColumn get songPath => text()();
IntColumn get position => integer()();
}
@DataClassName('MoorHomeWidget')
@DataClassName('DriftHomeWidget')
class HomeWidgets extends Table {
IntColumn get position => integer()();
TextColumn get type => text()();
@ -173,7 +171,7 @@ class HomeWidgets extends Table {
Set<Column> get primaryKey => {position};
}
@DataClassName('MoorHistoryEntry')
@DataClassName('DriftHistoryEntry')
class HistoryEntries extends Table {
DateTimeColumn get time => dateTime().withDefault(currentDateAndTime)();
TextColumn get type => text()();
@ -213,15 +211,12 @@ class BlockedFiles extends Table {
HistoryDao,
],
)
class MoorDatabase extends _$MoorDatabase {
/// Use MoorMusicDataSource in main isolate only.
MoorDatabase() : super(_openConnection());
class MainDatabase extends _$MainDatabase {
/// Use DriftMusicDataSource in main isolate only.
MainDatabase() : super(_openConnection());
/// Used for testing with in-memory database.
MoorDatabase.withQueryExecutor(QueryExecutor e) : super(e);
/// Used to connect to a database on another isolate.
MoorDatabase.connect(DatabaseConnection connection) : super.connect(connection);
MainDatabase.withQueryExecutor(QueryExecutor e) : super(e);
@override
int get schemaVersion => 12;
@ -420,44 +415,3 @@ LazyDatabase _openConnection() {
return NativeDatabase(file);
});
}
Future<DriftIsolate> createMoorIsolate() async {
// this method is called from the main isolate. Since we can't use
// getApplicationDocumentsDirectory on a background isolate, we calculate
// the database path in the foreground isolate and then inform the
// background isolate about the path.
final dir = await getApplicationDocumentsDirectory();
final path = p.join(dir.path, 'db.sqlite');
final receivePort = ReceivePort();
await Isolate.spawn(
_startBackground,
_IsolateStartRequest(receivePort.sendPort, path),
);
// _startBackground will send the MoorIsolate to this ReceivePort
return await receivePort.first as DriftIsolate;
}
void _startBackground(_IsolateStartRequest request) {
// this is the entry point from the background isolate! Let's create
// the database from the path we received
final executor = NativeDatabase(File(request.targetPath));
// we're using MoorIsolate.inCurrent here as this method already runs on a
// background isolate. If we used MoorIsolate.spawn, a third isolate would be
// started which is not what we want!
final moorIsolate = DriftIsolate.inCurrent(
() => DatabaseConnection.fromExecutor(executor),
);
// inform the starting isolate about this, so that it can call .connect()
request.sendMoorIsolate.send(moorIsolate);
}
// used to bundle the SendPort and the target path, since isolate entry point
// functions can only take one parameter.
class _IsolateStartRequest {
_IsolateStartRequest(this.sendMoorIsolate, this.targetPath);
final SendPort sendMoorIsolate;
final String targetPath;
}

4463
src/lib/system/datasources/moor_database.g.dart → src/lib/system/datasources/drift_database.g.dart
View file

File diff suppressed because it is too large Load diff

12
src/lib/system/datasources/moor/home_widget_dao.g.dart
View file

@ -1,12 +0,0 @@
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'home_widget_dao.dart';
// **************************************************************************
// DaoGenerator
// **************************************************************************
mixin _$HomeWidgetDaoMixin on DatabaseAccessor<MoorDatabase> {
$HomeWidgetsTable get homeWidgets => attachedDatabase.homeWidgets;
$KeyValueEntriesTable get keyValueEntries => attachedDatabase.keyValueEntries;
}

14
src/lib/system/models/album_model.dart
View file

@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
import 'package:on_audio_query/on_audio_query.dart' as aq;
import '../../domain/entities/album.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
import '../utils.dart';
import 'default_values.dart';
@ -15,12 +15,12 @@ class AlbumModel extends Album {
super.pubYear,
});
factory AlbumModel.fromMoor(MoorAlbum moorAlbum) => AlbumModel(
id: moorAlbum.id,
title: moorAlbum.title,
artist: moorAlbum.artist,
albumArtPath: moorAlbum.albumArtPath,
pubYear: moorAlbum.year,
factory AlbumModel.fromDrift(DriftAlbum driftAlbum) => AlbumModel(
id: driftAlbum.id,
title: driftAlbum.title,
artist: driftAlbum.artist,
albumArtPath: driftAlbum.albumArtPath,
pubYear: driftAlbum.year,
);
factory AlbumModel.fromOnAudioQuery({

8
src/lib/system/models/artist_model.dart
View file

@ -1,7 +1,7 @@
import 'package:drift/drift.dart';
import '../../domain/entities/artist.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
class ArtistModel extends Artist {
const ArtistModel({
@ -9,9 +9,9 @@ class ArtistModel extends Artist {
required super.name,
});
factory ArtistModel.fromMoor(MoorArtist moorArtist) => ArtistModel(
name: moorArtist.name,
id: moorArtist.id,
factory ArtistModel.fromDrift(DriftArtist driftArtist) => ArtistModel(
name: driftArtist.name,
id: driftArtist.id,
);
@override

8
src/lib/system/models/history_entry_model.dart
View file

@ -2,19 +2,19 @@ import 'package:drift/drift.dart';
import '../../domain/entities/history_entry.dart';
import '../../domain/entities/playable.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
class HistoryEntryModel extends HistoryEntry {
HistoryEntryModel({required super.time, required super.playable});
factory HistoryEntryModel.fromMoor(MoorHistoryEntry moorHistoryEntry, Playable playable) {
factory HistoryEntryModel.fromDrift(DriftHistoryEntry driftHistoryEntry, Playable playable) {
return HistoryEntryModel(
time: moorHistoryEntry.time,
time: driftHistoryEntry.time,
playable: playable,
);
}
HistoryEntriesCompanion toMoor() {
HistoryEntriesCompanion toDrift() {
return HistoryEntriesCompanion(
time: Value(time),
type: Value(playable.type.toString()),

10
src/lib/system/models/home_widgets/album_of_day_model.dart
View file

@ -2,19 +2,19 @@ import 'package:drift/drift.dart';
import '../../../domain/entities/home_widgets/album_of_day.dart';
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
import 'home_widget_model.dart';
class HomeAlbumOfDayModel extends HomeAlbumOfDay implements HomeWidgetModel {
HomeAlbumOfDayModel(super.position);
factory HomeAlbumOfDayModel.fromMoor(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
factory HomeAlbumOfDayModel.fromDrift(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
if (type != HomeWidgetType.album_of_day) {
throw TypeError();
}
return HomeAlbumOfDayModel(moorHomeWidget.position);
return HomeAlbumOfDayModel(driftHomeWidget.position);
}
factory HomeAlbumOfDayModel.fromEntity(HomeWidget entity) {
@ -26,7 +26,7 @@ class HomeAlbumOfDayModel extends HomeAlbumOfDay implements HomeWidgetModel {
}
@override
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
const data = '{}';
return HomeWidgetsCompanion(
position: Value(position),

12
src/lib/system/models/home_widgets/artist_of_day_model.dart
View file

@ -5,7 +5,7 @@ import 'package:drift/drift.dart';
import '../../../domain/entities/home_widgets/artist_of_day.dart';
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../../domain/entities/shuffle_mode.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
import 'home_widget_model.dart';
class HomeArtistOfDayModel extends HomeArtistOfDay implements HomeWidgetModel {
@ -17,15 +17,15 @@ class HomeArtistOfDayModel extends HomeArtistOfDay implements HomeWidgetModel {
shuffleMode: shuffleMode,
);
factory HomeArtistOfDayModel.fromMoor(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
factory HomeArtistOfDayModel.fromDrift(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
if (type != HomeWidgetType.artist_of_day) {
throw TypeError();
}
final data = jsonDecode(moorHomeWidget.data);
final data = jsonDecode(driftHomeWidget.data);
final shuffleMode = (data['shuffleMode'] as String).toShuffleMode();
return HomeArtistOfDayModel(moorHomeWidget.position, shuffleMode);
return HomeArtistOfDayModel(driftHomeWidget.position, shuffleMode);
}
factory HomeArtistOfDayModel.fromEntity(HomeWidget entity) {
@ -37,7 +37,7 @@ class HomeArtistOfDayModel extends HomeArtistOfDay implements HomeWidgetModel {
}
@override
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
final data = {'shuffleMode': '$shuffleMode'};
return HomeWidgetsCompanion(
position: Value(position),

12
src/lib/system/models/home_widgets/history_model.dart
View file

@ -4,7 +4,7 @@ import 'package:drift/drift.dart';
import '../../../domain/entities/home_widgets/history.dart';
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
import 'home_widget_model.dart';
class HomeHistoryModel extends HomeHistory implements HomeWidgetModel {
@ -16,15 +16,15 @@ class HomeHistoryModel extends HomeHistory implements HomeWidgetModel {
maxEntries: maxEntries,
);
factory HomeHistoryModel.fromMoor(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
factory HomeHistoryModel.fromDrift(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
if (type != HomeWidgetType.history) {
throw TypeError();
}
final data = jsonDecode(moorHomeWidget.data);
final data = jsonDecode(driftHomeWidget.data);
final maxEntries = data['maxEntries'] as int;
return HomeHistoryModel(moorHomeWidget.position, maxEntries);
return HomeHistoryModel(driftHomeWidget.position, maxEntries);
}
factory HomeHistoryModel.fromEntity(HomeWidget entity) {
@ -36,7 +36,7 @@ class HomeHistoryModel extends HomeHistory implements HomeWidgetModel {
}
@override
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
final data = {'maxEntries': maxEntries};
return HomeWidgetsCompanion(
position: Value(position),

4
src/lib/system/models/home_widgets/home_widget_model.dart
View file

@ -1,8 +1,8 @@
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
abstract class HomeWidgetModel extends HomeWidget {
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
throw UnimplementedError();
}
}

12
src/lib/system/models/home_widgets/playlists_model.dart
View file

@ -5,7 +5,7 @@ import 'package:drift/drift.dart';
import '../../../domain/entities/enums.dart';
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../../domain/entities/home_widgets/playlists.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
import 'home_widget_model.dart';
class HomePlaylistsModel extends HomePlaylists implements HomeWidgetModel {
@ -25,16 +25,16 @@ class HomePlaylistsModel extends HomePlaylists implements HomeWidgetModel {
filter: filter,
);
factory HomePlaylistsModel.fromMoor(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
factory HomePlaylistsModel.fromDrift(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
if (type != HomeWidgetType.playlists) {
throw TypeError();
}
final data = json.decode(moorHomeWidget.data);
final data = json.decode(driftHomeWidget.data);
return HomePlaylistsModel(
moorHomeWidget.position,
driftHomeWidget.position,
data['maxEntries'] as int,
data['title'] as String,
(data['orderCriterion'] as String).toHomePlaylistsOrder()!,
@ -59,7 +59,7 @@ class HomePlaylistsModel extends HomePlaylists implements HomeWidgetModel {
}
@override
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
final Map<String, dynamic> data = {
'title': title,
'maxEntries': maxEntries,

12
src/lib/system/models/home_widgets/shuffle_all_model.dart
View file

@ -5,7 +5,7 @@ import 'package:drift/drift.dart';
import '../../../domain/entities/home_widgets/home_widget.dart';
import '../../../domain/entities/home_widgets/shuffle_all.dart';
import '../../../domain/entities/shuffle_mode.dart';
import '../../datasources/moor_database.dart';
import '../../datasources/drift_database.dart';
import 'home_widget_model.dart';
class HomeShuffleAllModel extends HomeShuffleAll implements HomeWidgetModel {
@ -17,15 +17,15 @@ class HomeShuffleAllModel extends HomeShuffleAll implements HomeWidgetModel {
shuffleMode: shuffleMode,
);
factory HomeShuffleAllModel.fromMoor(MoorHomeWidget moorHomeWidget) {
final type = moorHomeWidget.type.toHomeWidgetType();
factory HomeShuffleAllModel.fromDrift(DriftHomeWidget driftHomeWidget) {
final type = driftHomeWidget.type.toHomeWidgetType();
if (type != HomeWidgetType.shuffle_all) {
throw TypeError();
}
final data = jsonDecode(moorHomeWidget.data);
final data = jsonDecode(driftHomeWidget.data);
final shuffleMode = (data['shuffleMode'] as String).toShuffleMode();
return HomeShuffleAllModel(moorHomeWidget.position, shuffleMode);
return HomeShuffleAllModel(driftHomeWidget.position, shuffleMode);
}
factory HomeShuffleAllModel.fromEntity(HomeWidget entity) {
@ -37,7 +37,7 @@ class HomeShuffleAllModel extends HomeShuffleAll implements HomeWidgetModel {
}
@override
HomeWidgetsCompanion toMoor() {
HomeWidgetsCompanion toDrift() {
final data = {'shuffleMode': '$shuffleMode'};
return HomeWidgetsCompanion(
position: Value(position),

20
src/lib/system/models/playlist_model.dart
View file

@ -2,7 +2,7 @@ import 'package:drift/drift.dart' as m;
import '../../domain/entities/playlist.dart';
import '../../domain/entities/shuffle_mode.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
class PlaylistModel extends Playlist {
const PlaylistModel({
@ -38,16 +38,16 @@ class PlaylistModel extends Playlist {
);
}
factory PlaylistModel.fromMoor(MoorPlaylist moorPlaylist) {
factory PlaylistModel.fromDrift(DriftPlaylist driftPlaylist) {
return PlaylistModel(
id: moorPlaylist.id,
name: moorPlaylist.name,
iconString: moorPlaylist.icon,
gradientString: moorPlaylist.gradient,
shuffleMode: moorPlaylist.shuffleMode?.toShuffleMode(),
timeChanged: moorPlaylist.timeChanged,
timeCreated: moorPlaylist.timeCreated,
timeLastPlayed: moorPlaylist.timeLastPlayed,
id: driftPlaylist.id,
name: driftPlaylist.name,
iconString: driftPlaylist.icon,
gradientString: driftPlaylist.gradient,
shuffleMode: driftPlaylist.shuffleMode?.toShuffleMode(),
timeChanged: driftPlaylist.timeChanged,
timeCreated: driftPlaylist.timeCreated,
timeLastPlayed: driftPlaylist.timeLastPlayed,
);
}

50
src/lib/system/models/smart_list_model.dart
View file

@ -3,7 +3,7 @@ import 'package:drift/drift.dart' as m;
import '../../domain/entities/enums.dart';
import '../../domain/entities/shuffle_mode.dart';
import '../../domain/entities/smart_list.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
import 'artist_model.dart';
class SmartListModel extends SmartList {
@ -46,22 +46,22 @@ class SmartListModel extends SmartList {
);
}
factory SmartListModel.fromMoor(MoorSmartList moorSmartList, List<MoorArtist>? artists) {
factory SmartListModel.fromDrift(DriftSmartList driftSmartList, List<DriftArtist>? artists) {
final filter = Filter(
artists: artists?.map((MoorArtist a) => ArtistModel.fromMoor(a)).toList(),
excludeArtists: moorSmartList.excludeArtists,
minLikeCount: moorSmartList.minLikeCount,
maxLikeCount: moorSmartList.maxLikeCount,
minPlayCount: moorSmartList.minPlayCount,
maxPlayCount: moorSmartList.maxPlayCount,
minYear: moorSmartList.minYear,
maxYear: moorSmartList.maxYear,
blockLevel: moorSmartList.blockLevel,
limit: moorSmartList.limit,
artists: artists?.map((DriftArtist a) => ArtistModel.fromDrift(a)).toList(),
excludeArtists: driftSmartList.excludeArtists,
minLikeCount: driftSmartList.minLikeCount,
maxLikeCount: driftSmartList.maxLikeCount,
minPlayCount: driftSmartList.minPlayCount,
maxPlayCount: driftSmartList.maxPlayCount,
minYear: driftSmartList.minYear,
maxYear: driftSmartList.maxYear,
blockLevel: driftSmartList.blockLevel,
limit: driftSmartList.limit,
);
final criteria = _parseOrderCriteria(moorSmartList.orderCriteria);
final directions = _parseOrderDirections(moorSmartList.orderDirections);
final criteria = _parseOrderCriteria(driftSmartList.orderCriteria);
final directions = _parseOrderDirections(driftSmartList.orderDirections);
final filteredDirections = <OrderDirection>[];
criteria.asMap().forEach((key, value) {
@ -74,16 +74,16 @@ class SmartListModel extends SmartList {
);
return SmartListModel(
id: moorSmartList.id,
name: moorSmartList.name,
id: driftSmartList.id,
name: driftSmartList.name,
filter: filter,
orderBy: orderBy,
shuffleMode: moorSmartList.shuffleMode?.toShuffleMode(),
iconString: moorSmartList.icon,
gradientString: moorSmartList.gradient,
timeChanged: moorSmartList.timeChanged,
timeCreated: moorSmartList.timeCreated,
timeLastPlayed: moorSmartList.timeLastPlayed,
shuffleMode: driftSmartList.shuffleMode?.toShuffleMode(),
iconString: driftSmartList.icon,
gradientString: driftSmartList.gradient,
timeChanged: driftSmartList.timeChanged,
timeCreated: driftSmartList.timeCreated,
timeLastPlayed: driftSmartList.timeLastPlayed,
);
}
@ -111,7 +111,7 @@ class SmartListModel extends SmartList {
timeLastPlayed: m.Value(timeLastPlayed),
);
List<SmartListArtistsCompanion> toMoorArtists() {
List<SmartListArtistsCompanion> toDriftArtists() {
if (filter.artists == null) return [];
return filter.artists!
.map(
@ -136,8 +136,8 @@ List<OrderDirection> _parseOrderDirections(String orderDirections) {
return odList.map((e) => e.toOrderDirection()!).toList();
}
extension ToMoorExtension on OrderDirection {
m.OrderingMode toMoor() {
extension ToDriftExtension on OrderDirection {
m.OrderingMode toDrift() {
switch (this) {
case OrderDirection.ascending:
return m.OrderingMode.asc;

40
src/lib/system/models/song_model.dart
View file

@ -3,7 +3,7 @@ import 'package:drift/drift.dart';
import 'package:on_audio_query/on_audio_query.dart' as aq;
import '../../domain/entities/song.dart';
import '../datasources/moor_database.dart';
import '../datasources/drift_database.dart';
import '../utils.dart';
import 'default_values.dart';
@ -45,24 +45,24 @@ class SongModel extends Song {
year: year,
);
factory SongModel.fromMoor(MoorSong moorSong) => SongModel(
album: moorSong.albumTitle,
albumId: moorSong.albumId,
artist: moorSong.artist,
blockLevel: moorSong.blockLevel,
duration: Duration(milliseconds: moorSong.duration),
path: moorSong.path,
title: moorSong.title,
albumArtPath: moorSong.albumArtPath,
discNumber: moorSong.discNumber,
next: moorSong.next,
previous: moorSong.previous,
trackNumber: moorSong.trackNumber,
likeCount: moorSong.likeCount,
playCount: moorSong.playCount,
timeAdded: moorSong.timeAdded,
lastModified: moorSong.lastModified,
year: moorSong.year,
factory SongModel.fromDrift(DriftSong driftSong) => SongModel(
album: driftSong.albumTitle,
albumId: driftSong.albumId,
artist: driftSong.artist,
blockLevel: driftSong.blockLevel,
duration: Duration(milliseconds: driftSong.duration),
path: driftSong.path,
title: driftSong.title,
albumArtPath: driftSong.albumArtPath,
discNumber: driftSong.discNumber,
next: driftSong.next,
previous: driftSong.previous,
trackNumber: driftSong.trackNumber,
likeCount: driftSong.likeCount,
playCount: driftSong.playCount,
timeAdded: driftSong.timeAdded,
lastModified: driftSong.lastModified,
year: driftSong.year,
);
factory SongModel.fromOnAudioQuery({
@ -163,7 +163,7 @@ class SongModel extends Song {
lastModified: Value(lastModified),
);
SongsCompanion toMoorInsert() => SongsCompanion(
SongsCompanion toDriftInsert() => SongsCompanion(
albumTitle: Value(album),
albumId: Value(albumId),
artist: Value(artist),

480
src/pubspec.lock
View file

File diff suppressed because it is too large Load diff

16
src/pubspec.yaml
View file

@ -11,17 +11,17 @@ environment:
dependencies:
audio_service: ^0.18.7 # MIT
audio_session: ^0.1.5 # MIT
collection: ^1.15.0 # BSD 3
drift: ^1.0.0 # MIT
collection: ^1.17.0 # BSD 3
drift: ^2.5.0 # MIT
equatable: ^2.0.3 # MIT
file_picker: ^4.3.0 # MIT
file_picker: ^5.2.5 # MIT
fimber: ^0.6.1 # Apache 2.0
flutter:
sdk: flutter
flutter_fimber: ^0.6.3 # Apache 2.0
flutter_fimber_filelogger: ^2.0.0 # DEPRECATED -> fimber_io
flutter_mobx: ^2.0.0 # MIT
flutter_speed_dial: ^5.0.0 # MIT
flutter_speed_dial: ^6.2.0 # MIT
get_it: ^7.1.3 # MIT
just_audio: ^0.9.18 # MIT
mobx: ^2.0.1 # MIT
@ -29,15 +29,15 @@ dependencies:
palette_generator: ^0.3.3+2 # BSD 3
path: ^1.8.0 # BSD 3
path_provider: ^2.0.2 # BSD 3
permission_handler: ^8.3.0 # MIT
permission_handler: ^10.2.0 # MIT
provider: ^6.0.2 # MIT
reorderables: ^0.4.1 # MIT
reorderables: ^0.6.0 # MIT
sqlite3_flutter_libs: ^0.5.0 # MIT
string_similarity: ^2.0.0 # MIT
dev_dependencies:
build_runner: ^2.0.4 # BSD 3
drift_dev: ^1.0.0 # MIT
build_runner: ^2.3.3 # BSD 3
drift_dev: ^2.5.0 # MIT
flutter_test:
sdk: flutter
mobx_codegen: ^2.0.1+3 # MIT