added cargo files
This commit is contained in:
@@ -0,0 +1,808 @@
|
||||
// Copyright 2019 Ben Hills. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
import 'dart:collection';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:pinepods_mobile/api/podcast/podcast_api.dart';
|
||||
import 'package:pinepods_mobile/core/utils.dart';
|
||||
import 'package:pinepods_mobile/entities/chapter.dart';
|
||||
import 'package:pinepods_mobile/entities/downloadable.dart';
|
||||
import 'package:pinepods_mobile/entities/episode.dart';
|
||||
import 'package:pinepods_mobile/entities/funding.dart';
|
||||
import 'package:pinepods_mobile/entities/person.dart';
|
||||
import 'package:pinepods_mobile/entities/podcast.dart';
|
||||
import 'package:pinepods_mobile/entities/transcript.dart';
|
||||
import 'package:pinepods_mobile/l10n/messages_all.dart';
|
||||
import 'package:pinepods_mobile/services/podcast/podcast_service.dart';
|
||||
import 'package:pinepods_mobile/state/episode_state.dart';
|
||||
import 'package:collection/collection.dart' show IterableExtension;
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_downloader/flutter_downloader.dart';
|
||||
import 'package:intl/intl.dart';
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:path/path.dart';
|
||||
import 'package:podcast_search/podcast_search.dart' as podcast_search;
|
||||
|
||||
class MobilePodcastService extends PodcastService {
|
||||
final descriptionRegExp1 = RegExp(r'(</p><br>|</p></br>|<p><br></p>|<p></br></p>)');
|
||||
final descriptionRegExp2 = RegExp(r'(<p><br></p>|<p></br></p>)');
|
||||
final log = Logger('MobilePodcastService');
|
||||
final _cache = _PodcastCache(maxItems: 10, expiration: const Duration(minutes: 30));
|
||||
var _categories = <String>[];
|
||||
var _intlCategories = <String?>[];
|
||||
var _intlCategoriesSorted = <String>[];
|
||||
|
||||
MobilePodcastService({
|
||||
required super.api,
|
||||
required super.repository,
|
||||
required super.settingsService,
|
||||
}) {
|
||||
_init();
|
||||
}
|
||||
|
||||
Future<void> _init() async {
|
||||
final List<Locale> systemLocales = PlatformDispatcher.instance.locales;
|
||||
|
||||
var currentLocale = Platform.localeName;
|
||||
// Attempt to get current locale
|
||||
var supportedLocale = await initializeMessages(Platform.localeName);
|
||||
|
||||
// If we do not support the default, try all supported locales
|
||||
if (!supportedLocale) {
|
||||
for (var l in systemLocales) {
|
||||
supportedLocale = await initializeMessages('${l.languageCode}_${l.countryCode}');
|
||||
if (supportedLocale) {
|
||||
currentLocale = '${l.languageCode}_${l.countryCode}';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!supportedLocale) {
|
||||
// We give up! Default to English
|
||||
currentLocale = 'en';
|
||||
supportedLocale = await initializeMessages(currentLocale);
|
||||
}
|
||||
}
|
||||
|
||||
_setupGenres(currentLocale);
|
||||
|
||||
/// Listen for user changes in search provider. If changed, reload the genre list
|
||||
settingsService.settingsListener.where((event) => event == 'search').listen((event) {
|
||||
_setupGenres(currentLocale);
|
||||
});
|
||||
}
|
||||
|
||||
void _setupGenres(String locale) {
|
||||
var categoryList = '';
|
||||
|
||||
/// Fetch the correct categories for the current local and selected provider.
|
||||
if (settingsService.searchProvider == 'itunes') {
|
||||
_categories = PodcastService.itunesGenres;
|
||||
categoryList = Intl.message('discovery_categories_itunes', locale: locale);
|
||||
} else {
|
||||
_categories = PodcastService.podcastIndexGenres;
|
||||
categoryList = Intl.message('discovery_categories_pindex', locale: locale);
|
||||
}
|
||||
|
||||
_intlCategories = categoryList.split(',');
|
||||
_intlCategoriesSorted = categoryList.split(',');
|
||||
_intlCategoriesSorted.sort((a, b) => a.toLowerCase().compareTo(b.toLowerCase()));
|
||||
}
|
||||
|
||||
@override
|
||||
Future<podcast_search.SearchResult> search({
|
||||
required String term,
|
||||
String? country,
|
||||
String? attribute,
|
||||
int? limit,
|
||||
String? language,
|
||||
int version = 0,
|
||||
bool explicit = false,
|
||||
}) {
|
||||
return api.search(
|
||||
term,
|
||||
country: country,
|
||||
attribute: attribute,
|
||||
limit: limit,
|
||||
language: language,
|
||||
explicit: explicit,
|
||||
searchProvider: settingsService.searchProvider,
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<podcast_search.SearchResult> charts({
|
||||
int size = 20,
|
||||
String? genre,
|
||||
String? countryCode = '',
|
||||
String? languageCode = '',
|
||||
}) {
|
||||
var providerGenre = _decodeGenre(genre);
|
||||
|
||||
return api.charts(
|
||||
size: size,
|
||||
searchProvider: settingsService.searchProvider,
|
||||
genre: providerGenre,
|
||||
countryCode: countryCode,
|
||||
languageCode: languageCode,
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
List<String> genres() {
|
||||
return _intlCategoriesSorted;
|
||||
}
|
||||
|
||||
/// Loads the specified [Podcast]. If the Podcast instance has an ID we'll fetch
|
||||
/// it from storage. If not, we'll check the cache to see if we have seen it
|
||||
/// recently and return that if available. If not, we'll make a call to load
|
||||
/// it from the network.
|
||||
/// TODO: The complexity of this method is now too high - needs to be refactored.
|
||||
@override
|
||||
Future<Podcast?> loadPodcast({
|
||||
required Podcast podcast,
|
||||
bool highlightNewEpisodes = false,
|
||||
bool refresh = false,
|
||||
}) async {
|
||||
log.fine('loadPodcast. ID ${podcast.id} (refresh $refresh)');
|
||||
|
||||
if (podcast.id == null || refresh) {
|
||||
podcast_search.Podcast? loadedPodcast;
|
||||
var imageUrl = podcast.imageUrl;
|
||||
var thumbImageUrl = podcast.thumbImageUrl;
|
||||
var sourceUrl = podcast.url;
|
||||
|
||||
if (!refresh) {
|
||||
log.fine('Not a refresh so try to fetch from cache');
|
||||
loadedPodcast = _cache.item(podcast.url);
|
||||
}
|
||||
|
||||
// If we didn't get a cache hit load the podcast feed.
|
||||
if (loadedPodcast == null) {
|
||||
var tries = 2;
|
||||
var url = podcast.url;
|
||||
|
||||
while (tries-- > 0) {
|
||||
try {
|
||||
log.fine('Loading podcast from feed $url');
|
||||
loadedPodcast = await _loadPodcastFeed(url: url);
|
||||
tries = 0;
|
||||
} catch (e) {
|
||||
if (tries > 0) {
|
||||
//TODO: Needs improving to only fall back if original URL was http and we forced it up to https.
|
||||
if (e is podcast_search.PodcastCertificateException && url.startsWith('https')) {
|
||||
log.fine('Certificate error whilst fetching podcast. Fallback to http and try again');
|
||||
|
||||
url = url.replaceFirst('https', 'http');
|
||||
}
|
||||
} else {
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_cache.store(loadedPodcast!);
|
||||
}
|
||||
|
||||
final title = _format(loadedPodcast.title);
|
||||
final description = _format(loadedPodcast.description);
|
||||
final copyright = _format(loadedPodcast.copyright);
|
||||
final funding = <Funding>[];
|
||||
final persons = <Person>[];
|
||||
final existingEpisodes = await repository.findEpisodesByPodcastGuid(sourceUrl);
|
||||
|
||||
// If imageUrl is null we have not loaded the podcast as a result of a search.
|
||||
if (imageUrl == null || imageUrl.isEmpty || refresh) {
|
||||
imageUrl = loadedPodcast.image;
|
||||
thumbImageUrl = loadedPodcast.image;
|
||||
}
|
||||
|
||||
for (var f in loadedPodcast.funding) {
|
||||
if (f.url != null) {
|
||||
funding.add(Funding(url: f.url!, value: f.value ?? ''));
|
||||
}
|
||||
}
|
||||
|
||||
for (var p in loadedPodcast.persons) {
|
||||
persons.add(Person(
|
||||
name: p.name,
|
||||
role: p.role ?? '',
|
||||
group: p.group ?? '',
|
||||
image: p.image,
|
||||
link: p.link,
|
||||
));
|
||||
}
|
||||
|
||||
Podcast pc = Podcast(
|
||||
guid: sourceUrl,
|
||||
url: sourceUrl,
|
||||
link: loadedPodcast.link,
|
||||
title: title,
|
||||
description: description,
|
||||
imageUrl: imageUrl,
|
||||
thumbImageUrl: thumbImageUrl,
|
||||
copyright: copyright,
|
||||
funding: funding,
|
||||
persons: persons,
|
||||
episodes: <Episode>[],
|
||||
);
|
||||
|
||||
/// We could be following this podcast already. Let's check.
|
||||
var follow = await repository.findPodcastByGuid(sourceUrl);
|
||||
|
||||
if (follow != null) {
|
||||
// We are, so swap in the stored ID so we update the saved version later.
|
||||
pc.id = follow.id;
|
||||
|
||||
// And preserve any filter & sort applied
|
||||
pc.filter = follow.filter;
|
||||
pc.sort = follow.sort;
|
||||
}
|
||||
|
||||
// Usually, episodes are order by reverse publication date - but not always.
|
||||
// Enforce that ordering. To prevent unnecessary sorting, we'll sample the
|
||||
// first two episodes to see what order they are in.
|
||||
if (loadedPodcast.episodes.length > 1) {
|
||||
if (loadedPodcast.episodes[0].publicationDate!.millisecondsSinceEpoch <
|
||||
loadedPodcast.episodes[1].publicationDate!.millisecondsSinceEpoch) {
|
||||
loadedPodcast.episodes.sort((e1, e2) => e2.publicationDate!.compareTo(e1.publicationDate!));
|
||||
}
|
||||
}
|
||||
|
||||
// Loop through all episodes in the feed and check to see if we already have that episode
|
||||
// stored. If we don't, it's a new episode so add it; if we do update our copy in case it's changed.
|
||||
for (final episode in loadedPodcast.episodes) {
|
||||
final existingEpisode = existingEpisodes.firstWhereOrNull((ep) => ep!.guid == episode.guid);
|
||||
final author = episode.author?.replaceAll('\n', '').trim() ?? '';
|
||||
final title = _format(episode.title);
|
||||
final description = _format(episode.description);
|
||||
final content = episode.content;
|
||||
|
||||
final episodeImage = episode.imageUrl == null || episode.imageUrl!.isEmpty ? pc.imageUrl : episode.imageUrl;
|
||||
final episodeThumbImage =
|
||||
episode.imageUrl == null || episode.imageUrl!.isEmpty ? pc.thumbImageUrl : episode.imageUrl;
|
||||
final duration = episode.duration?.inSeconds ?? 0;
|
||||
final transcriptUrls = <TranscriptUrl>[];
|
||||
final episodePersons = <Person>[];
|
||||
|
||||
for (var t in episode.transcripts) {
|
||||
late TranscriptFormat type;
|
||||
|
||||
switch (t.type) {
|
||||
case podcast_search.TranscriptFormat.subrip:
|
||||
type = TranscriptFormat.subrip;
|
||||
break;
|
||||
case podcast_search.TranscriptFormat.json:
|
||||
type = TranscriptFormat.json;
|
||||
break;
|
||||
case podcast_search.TranscriptFormat.vtt:
|
||||
type = TranscriptFormat.subrip; // Map VTT to subrip for now
|
||||
break;
|
||||
case podcast_search.TranscriptFormat.unsupported:
|
||||
type = TranscriptFormat.unsupported;
|
||||
break;
|
||||
}
|
||||
|
||||
transcriptUrls.add(TranscriptUrl(url: t.url, type: type));
|
||||
}
|
||||
|
||||
if (episode.persons.isNotEmpty) {
|
||||
for (var p in episode.persons) {
|
||||
episodePersons.add(Person(
|
||||
name: p.name,
|
||||
role: p.role!,
|
||||
group: p.group!,
|
||||
image: p.image,
|
||||
link: p.link,
|
||||
));
|
||||
}
|
||||
} else if (persons.isNotEmpty) {
|
||||
episodePersons.addAll(persons);
|
||||
}
|
||||
|
||||
if (existingEpisode == null) {
|
||||
pc.newEpisodes = highlightNewEpisodes && pc.id != null;
|
||||
|
||||
pc.episodes.add(Episode(
|
||||
highlight: pc.newEpisodes,
|
||||
pguid: pc.guid,
|
||||
guid: episode.guid,
|
||||
podcast: pc.title,
|
||||
title: title,
|
||||
description: description,
|
||||
content: content,
|
||||
author: author,
|
||||
season: episode.season ?? 0,
|
||||
episode: episode.episode ?? 0,
|
||||
contentUrl: episode.contentUrl,
|
||||
link: episode.link,
|
||||
imageUrl: episodeImage,
|
||||
thumbImageUrl: episodeThumbImage,
|
||||
duration: duration,
|
||||
publicationDate: episode.publicationDate,
|
||||
chaptersUrl: episode.chapters?.url,
|
||||
transcriptUrls: transcriptUrls,
|
||||
persons: episodePersons,
|
||||
chapters: <Chapter>[],
|
||||
));
|
||||
} else {
|
||||
/// Check if the ancillary episode data has changed.
|
||||
if (!listEquals(existingEpisode.persons, episodePersons) ||
|
||||
!listEquals(existingEpisode.transcriptUrls, transcriptUrls)) {
|
||||
pc.updatedEpisodes = true;
|
||||
}
|
||||
|
||||
existingEpisode.title = title;
|
||||
existingEpisode.description = description;
|
||||
existingEpisode.content = content;
|
||||
existingEpisode.author = author;
|
||||
existingEpisode.season = episode.season ?? 0;
|
||||
existingEpisode.episode = episode.episode ?? 0;
|
||||
existingEpisode.contentUrl = episode.contentUrl;
|
||||
existingEpisode.link = episode.link;
|
||||
existingEpisode.imageUrl = episodeImage;
|
||||
existingEpisode.thumbImageUrl = episodeThumbImage;
|
||||
existingEpisode.publicationDate = episode.publicationDate;
|
||||
existingEpisode.chaptersUrl = episode.chapters?.url;
|
||||
existingEpisode.transcriptUrls = transcriptUrls;
|
||||
existingEpisode.persons = episodePersons;
|
||||
|
||||
// If the source duration is 0 do not update any saved, calculated duration.
|
||||
if (duration > 0) {
|
||||
existingEpisode.duration = duration;
|
||||
}
|
||||
|
||||
pc.episodes.add(existingEpisode);
|
||||
|
||||
// Clear this episode from our existing list
|
||||
existingEpisodes.remove(existingEpisode);
|
||||
}
|
||||
}
|
||||
|
||||
// Add any downloaded episodes that are no longer in the feed - they
|
||||
// may have expired but we still want them.
|
||||
var expired = <Episode>[];
|
||||
|
||||
for (final episode in existingEpisodes) {
|
||||
var feedEpisode = loadedPodcast.episodes.firstWhereOrNull((ep) => ep.guid == episode!.guid);
|
||||
|
||||
if (feedEpisode == null && episode!.downloaded) {
|
||||
pc.episodes.add(episode);
|
||||
} else {
|
||||
expired.add(episode!);
|
||||
}
|
||||
}
|
||||
|
||||
// If we are subscribed to this podcast and are simply refreshing we need to save the updated subscription.
|
||||
// A non-null ID indicates this podcast is subscribed too. We also need to delete any expired episodes.
|
||||
if (podcast.id != null && refresh) {
|
||||
await repository.deleteEpisodes(expired);
|
||||
|
||||
pc = await repository.savePodcast(pc);
|
||||
|
||||
// Phew! Now, after all that, we have have a podcast filter in place. All episodes will have
|
||||
// been saved, but we might not want to display them all. Let's filter.
|
||||
pc.episodes = _sortAndFilterEpisodes(pc);
|
||||
}
|
||||
|
||||
return pc;
|
||||
} else {
|
||||
return await loadPodcastById(id: podcast.id ?? 0);
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Podcast?> loadPodcastById({required int id}) {
|
||||
return repository.findPodcastById(id);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Chapter>> loadChaptersByUrl({required String url}) async {
|
||||
var c = await _loadChaptersByUrl(url);
|
||||
var chapters = <Chapter>[];
|
||||
|
||||
if (c != null) {
|
||||
for (var chapter in c.chapters) {
|
||||
chapters.add(Chapter(
|
||||
title: chapter.title,
|
||||
url: chapter.url,
|
||||
imageUrl: chapter.imageUrl,
|
||||
startTime: chapter.startTime,
|
||||
endTime: chapter.endTime,
|
||||
toc: chapter.toc,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
return chapters;
|
||||
}
|
||||
|
||||
/// This method will load either of the supported transcript types. Currently, we do not support
|
||||
/// word level highlighting of transcripts, therefore this routine will also group transcript
|
||||
/// lines together by speaker and/or timeframe.
|
||||
@override
|
||||
Future<Transcript> loadTranscriptByUrl({required TranscriptUrl transcriptUrl}) async {
|
||||
var subtitles = <Subtitle>[];
|
||||
var result = await _loadTranscriptByUrl(transcriptUrl);
|
||||
var threshold = const Duration(seconds: 5);
|
||||
Subtitle? groupSubtitle;
|
||||
|
||||
if (result != null) {
|
||||
for (var index = 0; index < result.subtitles.length; index++) {
|
||||
var subtitle = result.subtitles[index];
|
||||
var completeGroup = true;
|
||||
var data = subtitle.data;
|
||||
|
||||
if (groupSubtitle != null) {
|
||||
if (transcriptUrl.type == TranscriptFormat.json) {
|
||||
if (groupSubtitle.speaker == subtitle.speaker &&
|
||||
(subtitle.start.compareTo(groupSubtitle.start + threshold) < 0 || subtitle.data.length == 1)) {
|
||||
/// We need to handle transcripts that have spaces between sentences, and those
|
||||
/// which do not.
|
||||
if (groupSubtitle.data != null &&
|
||||
(groupSubtitle.data!.endsWith(' ') || subtitle.data.startsWith(' ') || subtitle.data.length == 1)) {
|
||||
data = '${groupSubtitle.data}${subtitle.data}';
|
||||
} else {
|
||||
data = '${groupSubtitle.data} ${subtitle.data.trim()}';
|
||||
}
|
||||
completeGroup = false;
|
||||
}
|
||||
} else {
|
||||
if (groupSubtitle.start == subtitle.start) {
|
||||
if (groupSubtitle.data != null &&
|
||||
(groupSubtitle.data!.endsWith(' ') || subtitle.data.startsWith(' ') || subtitle.data.length == 1)) {
|
||||
data = '${groupSubtitle.data}${subtitle.data}';
|
||||
} else {
|
||||
data = '${groupSubtitle.data} ${subtitle.data.trim()}';
|
||||
}
|
||||
completeGroup = false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
completeGroup = false;
|
||||
groupSubtitle = Subtitle(
|
||||
data: subtitle.data,
|
||||
speaker: subtitle.speaker,
|
||||
start: subtitle.start,
|
||||
end: subtitle.end,
|
||||
index: subtitle.index,
|
||||
);
|
||||
}
|
||||
|
||||
/// If we have a complete group, or we're the very last subtitle - add it.
|
||||
if (completeGroup || index == result.subtitles.length - 1) {
|
||||
groupSubtitle.data = groupSubtitle.data?.trim();
|
||||
|
||||
subtitles.add(groupSubtitle);
|
||||
|
||||
groupSubtitle = Subtitle(
|
||||
data: subtitle.data,
|
||||
speaker: subtitle.speaker,
|
||||
start: subtitle.start,
|
||||
end: subtitle.end,
|
||||
index: subtitle.index,
|
||||
);
|
||||
} else {
|
||||
groupSubtitle = Subtitle(
|
||||
data: data,
|
||||
speaker: subtitle.speaker,
|
||||
start: groupSubtitle.start,
|
||||
end: subtitle.end,
|
||||
index: groupSubtitle.index,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Transcript(subtitles: subtitles);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Episode>> loadDownloads() async {
|
||||
return repository.findDownloads();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Episode>> loadEpisodes() async {
|
||||
return repository.findAllEpisodes();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> deleteDownload(Episode episode) async {
|
||||
// If this episode is currently downloading, cancel the download first.
|
||||
if (episode.downloadState == DownloadState.downloaded) {
|
||||
if (settingsService.markDeletedEpisodesAsPlayed) {
|
||||
episode.played = true;
|
||||
}
|
||||
} else if (episode.downloadState == DownloadState.downloading && episode.downloadPercentage! < 100) {
|
||||
await FlutterDownloader.cancel(taskId: episode.downloadTaskId!);
|
||||
}
|
||||
|
||||
episode.downloadTaskId = null;
|
||||
episode.downloadPercentage = 0;
|
||||
episode.position = 0;
|
||||
episode.downloadState = DownloadState.none;
|
||||
|
||||
if (episode.transcriptId != null && episode.transcriptId! > 0) {
|
||||
await repository.deleteTranscriptById(episode.transcriptId!);
|
||||
}
|
||||
|
||||
await repository.saveEpisode(episode);
|
||||
|
||||
if (await hasStoragePermission()) {
|
||||
final f = File.fromUri(Uri.file(await resolvePath(episode)));
|
||||
|
||||
log.fine('Deleting file ${f.path}');
|
||||
|
||||
if (await f.exists()) {
|
||||
f.delete();
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> toggleEpisodePlayed(Episode episode) async {
|
||||
episode.played = !episode.played;
|
||||
episode.position = 0;
|
||||
|
||||
repository.saveEpisode(episode);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Podcast>> subscriptions() {
|
||||
return repository.subscriptions();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> unsubscribe(Podcast podcast) async {
|
||||
if (await hasStoragePermission()) {
|
||||
final filename = join(await getStorageDirectory(), safeFile(podcast.title));
|
||||
|
||||
final d = Directory.fromUri(Uri.file(filename));
|
||||
|
||||
if (await d.exists()) {
|
||||
await d.delete(recursive: true);
|
||||
}
|
||||
}
|
||||
|
||||
return repository.deletePodcast(podcast);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Podcast?> subscribe(Podcast? podcast) async {
|
||||
// We may already have episodes download for this podcast before the user
|
||||
// hit subscribe.
|
||||
if (podcast != null && podcast.guid != null) {
|
||||
var savedEpisodes = await repository.findEpisodesByPodcastGuid(podcast.guid!);
|
||||
|
||||
if (podcast.episodes.isNotEmpty) {
|
||||
for (var episode in podcast.episodes) {
|
||||
var savedEpisode = savedEpisodes.firstWhereOrNull((ep) => ep!.guid == episode.guid);
|
||||
|
||||
if (savedEpisode != null) {
|
||||
episode.pguid = podcast.guid;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return repository.savePodcast(podcast);
|
||||
}
|
||||
|
||||
return Future.value(null);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Podcast?> save(Podcast podcast, {bool withEpisodes = true}) async {
|
||||
return repository.savePodcast(podcast, withEpisodes: withEpisodes);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Episode> saveEpisode(Episode episode) async {
|
||||
return repository.saveEpisode(episode);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Episode>> saveEpisodes(List<Episode> episodes) async {
|
||||
return repository.saveEpisodes(episodes);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Transcript> saveTranscript(Transcript transcript) async {
|
||||
return repository.saveTranscript(transcript);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> saveQueue(List<Episode> episodes) async {
|
||||
await repository.saveQueue(episodes);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<Episode>> loadQueue() async {
|
||||
return await repository.loadQueue();
|
||||
}
|
||||
|
||||
/// Remove HTML padding from the content. The padding may look fine within
|
||||
/// the context of a browser, but can look out of place on a mobile screen.
|
||||
String _format(String? input) {
|
||||
return input?.trim().replaceAll(descriptionRegExp2, '').replaceAll(descriptionRegExp1, '</p>') ?? '';
|
||||
}
|
||||
|
||||
Future<podcast_search.Chapters?> _loadChaptersByUrl(String url) {
|
||||
return compute<_FeedComputer, podcast_search.Chapters?>(
|
||||
_loadChaptersByUrlCompute, _FeedComputer(api: api, url: url));
|
||||
}
|
||||
|
||||
static Future<podcast_search.Chapters?> _loadChaptersByUrlCompute(_FeedComputer c) async {
|
||||
podcast_search.Chapters? result;
|
||||
|
||||
try {
|
||||
result = await c.api.loadChapters(c.url);
|
||||
} catch (e) {
|
||||
final log = Logger('MobilePodcastService');
|
||||
|
||||
log.fine('Failed to download chapters');
|
||||
log.fine(e);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Future<podcast_search.Transcript?> _loadTranscriptByUrl(TranscriptUrl transcriptUrl) {
|
||||
return compute<_TranscriptComputer, podcast_search.Transcript?>(
|
||||
_loadTranscriptByUrlCompute, _TranscriptComputer(api: api, transcriptUrl: transcriptUrl));
|
||||
}
|
||||
|
||||
static Future<podcast_search.Transcript?> _loadTranscriptByUrlCompute(_TranscriptComputer c) async {
|
||||
podcast_search.Transcript? result;
|
||||
|
||||
try {
|
||||
result = await c.api.loadTranscript(c.transcriptUrl);
|
||||
} catch (e) {
|
||||
final log = Logger('MobilePodcastService');
|
||||
|
||||
log.fine('Failed to download transcript');
|
||||
log.fine(e);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/// Loading and parsing a podcast feed can take several seconds. Larger feeds
|
||||
/// can end up blocking the UI thread. We perform our feed load in a
|
||||
/// separate isolate so that the UI can continue to present a loading
|
||||
/// indicator whilst the data is fetched without locking the UI.
|
||||
Future<podcast_search.Podcast> _loadPodcastFeed({required String url}) {
|
||||
return compute<_FeedComputer, podcast_search.Podcast>(_loadPodcastFeedCompute, _FeedComputer(api: api, url: url));
|
||||
}
|
||||
|
||||
/// We have to separate the process of calling compute as you cannot use
|
||||
/// named parameters with compute. The podcast feed load API uses named
|
||||
/// parameters so we need to change it to a single, positional parameter.
|
||||
static Future<podcast_search.Podcast> _loadPodcastFeedCompute(_FeedComputer c) {
|
||||
return c.api.loadFeed(c.url);
|
||||
}
|
||||
|
||||
/// The service providers expect the genre to be passed in English. This function takes
|
||||
/// the selected genre and returns the English version.
|
||||
String _decodeGenre(String? genre) {
|
||||
var index = _intlCategories.indexOf(genre);
|
||||
var decodedGenre = '';
|
||||
|
||||
if (index >= 0) {
|
||||
decodedGenre = _categories[index];
|
||||
|
||||
if (decodedGenre == '<All>') {
|
||||
decodedGenre = '';
|
||||
}
|
||||
}
|
||||
|
||||
return decodedGenre;
|
||||
}
|
||||
|
||||
List<Episode> _sortAndFilterEpisodes(Podcast podcast) {
|
||||
var filteredEpisodes = <Episode>[];
|
||||
|
||||
switch (podcast.filter) {
|
||||
case PodcastEpisodeFilter.none:
|
||||
filteredEpisodes = podcast.episodes;
|
||||
break;
|
||||
case PodcastEpisodeFilter.started:
|
||||
filteredEpisodes = podcast.episodes.where((e) => e.highlight || e.position > 0).toList();
|
||||
break;
|
||||
case PodcastEpisodeFilter.played:
|
||||
filteredEpisodes = podcast.episodes.where((e) => e.highlight || e.played).toList();
|
||||
break;
|
||||
case PodcastEpisodeFilter.notPlayed:
|
||||
filteredEpisodes = podcast.episodes.where((e) => e.highlight || !e.played).toList();
|
||||
break;
|
||||
}
|
||||
|
||||
switch (podcast.sort) {
|
||||
case PodcastEpisodeSort.none:
|
||||
case PodcastEpisodeSort.latestFirst:
|
||||
filteredEpisodes.sort((e1, e2) => e2.publicationDate!.compareTo(e1.publicationDate!));
|
||||
case PodcastEpisodeSort.earliestFirst:
|
||||
filteredEpisodes.sort((e1, e2) => e1.publicationDate!.compareTo(e2.publicationDate!));
|
||||
case PodcastEpisodeSort.alphabeticalAscending:
|
||||
filteredEpisodes.sort((e1, e2) => e1.title!.toLowerCase().compareTo(e2.title!.toLowerCase()));
|
||||
case PodcastEpisodeSort.alphabeticalDescending:
|
||||
filteredEpisodes.sort((e1, e2) => e2.title!.toLowerCase().compareTo(e1.title!.toLowerCase()));
|
||||
}
|
||||
|
||||
return filteredEpisodes;
|
||||
}
|
||||
|
||||
@override
|
||||
Stream<Podcast?>? get podcastListener => repository.podcastListener;
|
||||
|
||||
@override
|
||||
Stream<EpisodeState>? get episodeListener => repository.episodeListener;
|
||||
}
|
||||
|
||||
/// A simple cache to reduce the number of network calls when loading podcast
|
||||
/// feeds. We can cache up to [maxItems] items with each item having an
|
||||
/// expiration time of [expiration]. The cache works as a FIFO queue, so if we
|
||||
/// attempt to store a new item in the cache and it is full we remove the
|
||||
/// first (and therefore oldest) item from the cache. Cache misses are returned
|
||||
/// as null.
|
||||
class _PodcastCache {
|
||||
final int maxItems;
|
||||
final Duration expiration;
|
||||
final Queue<_CacheItem> _queue;
|
||||
|
||||
_PodcastCache({required this.maxItems, required this.expiration}) : _queue = Queue<_CacheItem>();
|
||||
|
||||
podcast_search.Podcast? item(String key) {
|
||||
var hit = _queue.firstWhereOrNull((_CacheItem i) => i.podcast.url == key);
|
||||
podcast_search.Podcast? p;
|
||||
|
||||
if (hit != null) {
|
||||
var now = DateTime.now();
|
||||
|
||||
if (now.difference(hit.dateAdded) <= expiration) {
|
||||
p = hit.podcast;
|
||||
} else {
|
||||
_queue.remove(hit);
|
||||
}
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
void store(podcast_search.Podcast podcast) {
|
||||
if (_queue.length == maxItems) {
|
||||
_queue.removeFirst();
|
||||
}
|
||||
|
||||
_queue.addLast(_CacheItem(podcast));
|
||||
}
|
||||
}
|
||||
|
||||
/// A simple class that stores an instance of a Podcast and the
|
||||
/// date and time it was added. This can be used by the cache to
|
||||
/// keep a small and up-to-date list of searched for Podcasts.
|
||||
class _CacheItem {
|
||||
final podcast_search.Podcast podcast;
|
||||
final DateTime dateAdded;
|
||||
|
||||
_CacheItem(this.podcast) : dateAdded = DateTime.now();
|
||||
}
|
||||
|
||||
class _FeedComputer {
|
||||
final PodcastApi api;
|
||||
final String url;
|
||||
|
||||
_FeedComputer({required this.api, required this.url});
|
||||
}
|
||||
|
||||
class _TranscriptComputer {
|
||||
final PodcastApi api;
|
||||
final TranscriptUrl transcriptUrl;
|
||||
|
||||
_TranscriptComputer({required this.api, required this.transcriptUrl});
|
||||
}
|
||||
Reference in New Issue
Block a user