private async Task DeleteTrack(VKSaverTrack track)
{
_appLoaderService.Show(String.Format(_locService["AppLoader_DeletingItem"], track.Title));
var cleaner = _libraryDatabaseService.GetCleaner();
var result = await cleaner.RemoveItemAndCleanDependenciesAsync(track);
foreach (var item in result)
{
if (item is VKSaverTrack)
{
Tracks.Remove((VKSaverTrack)item);
var file = await MusicFilesPathHelper.GetFileFromCapatibleName(track.Source);
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
else if (item is VKSaverGenre)
{
if (((VKSaverGenre)item).DbKey == track.GenreKey)
{
_navigationService.GoBack();
}
}
}
_appLoaderService.Hide();
}
private async Task RecursiveScanFolder(StorageFolder folder)
{
var folders = await folder.GetFoldersAsync();
foreach (var childFolder in folders)
{
await RecursiveScanFolder(childFolder);
}
VKSaverFolder zFolder = null;
if (!_folders.TryGetValue(folder.Path, out zFolder))
{
zFolder = new VKSaverFolder
{
Name = folder.DisplayName,
Path = String.IsNullOrEmpty(folder.Path) ?
MusicFilesPathHelper.CAPATIBLE_MUSIC_FOLDER_NAME :
MusicFilesPathHelper.GetCapatibleSource(folder.Path),
Tracks = new List <VKSaverTrack>()
};
_folders[zFolder.Path] = zFolder;
}
var files = await folder.GetFilesAsync(CommonFileQuery.DefaultQuery);
_total += files.Count;
OnSearchingFilesProgressChanged();
var tracks = new List <VKSaverTrack>();
foreach (var file in files)
{
var track = await GetTrackInfo(file);
if (track != null)
{
tracks.Add(track);
zFolder.Tracks.Add(track);
}
_current++;
OnSearchingFilesProgressChanged();
}
await _database.InsertItems(tracks);
}
private async Task DeleteTrack(VKSaverTrack track)
{
_appLoaderService.Show(String.Format(_locService["AppLoader_DeletingItem"], track.Title));
var cleaner = _libraryDatabaseService.GetCleaner();
var result = await cleaner.RemoveItemAndCleanDependenciesAsync(track);
foreach (var item in result)
{
if (item is VKSaverTrack)
{
var itemTrack = (VKSaverTrack)item;
_allTracks?.Remove(itemTrack);
DeleteItemFromGroups(itemTrack, Tracks);
if (itemTrack.VKInfoKey != null)
{
_allCachedTracks?.Remove(itemTrack);
DeleteItemFromGroups(itemTrack, Cached);
}
var file = await MusicFilesPathHelper.GetFileFromCapatibleName(track.Source);
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
else if (item is VKSaverArtist)
{
DeleteItemFromGroups((VKSaverArtist)item, Artists);
}
else if (item is VKSaverGenre)
{
DeleteItemFromGroups((VKSaverGenre)item, Genres);
}
else if (item is VKSaverAlbum)
{
DeleteItemFromGroups((VKSaverAlbum)item, Albums);
}
else if (item is VKSaverFolder)
{
Folders.Remove((VKSaverFolder)item);
}
}
_libraryDatabaseService.NeedReloadLibraryView = false;
_appLoaderService.Hide();
}
private async Task <VKSaverTrack> GetTrackInfo(StorageFile file)
{
VKSaverTrack track = null;
try
{
if (file.FileType == ".mp3")
{
track = await ProcessMp3File(file);
}
else if (file.FileType == MusicCacheService.FILES_EXTENSION) // Кэшированный файл ВКачай.
{
track = await ProcessVKSaverAudioFile(file);
}
}
catch (Exception) { }
if (track != null)
{
track.Source = MusicFilesPathHelper.GetCapatibleSource(file.Path);
}
return(track);
}
public async Task InsertDownloadedTrack(VKSaverAudio audio, string folderPath, string filePath)
{
string artistName = null;
string capatibleFolderPath = MusicFilesPathHelper.GetCapatibleSource(folderPath);
string genreKey = audio.VK.Genre == 0 ? UNKNOWN_GENRE_NAME : audio.VK.Genre.ToString();
string vkInfoKey = $"{audio.VK.OwnerID} {audio.VK.ID}";
if (String.IsNullOrEmpty(audio.Track.Artist))
{
artistName = UNKNOWN_ARTIST_NAME;
}
else
{
artistName = audio.Track.Artist;
}
string albumKey = $"{artistName}-{UNKNOWN_ALBUM_NAME}";
var dbFolder = await _database.FindItem <VKSaverFolder>(capatibleFolderPath);
if (dbFolder == null)
{
dbFolder = new VKSaverFolder
{
Path = capatibleFolderPath,
Name = Path.GetFileName(folderPath),
Tracks = new List <VKSaverTrack>()
};
await _database.InsertItem(dbFolder);
}
else
{
dbFolder = null;
}
var dbAlbum = await _database.FindItem <VKSaverAlbum>(albumKey);
if (dbAlbum == null)
{
dbAlbum = new VKSaverAlbum
{
DbKey = albumKey,
Name = UNKNOWN_ALBUM_NAME,
ArtistName = artistName,
Tracks = new List <VKSaverTrack>()
};
await _database.InsertItem(dbAlbum);
}
else
{
dbAlbum = null;
}
var dbArtist = await _database.FindItem <VKSaverArtist>(artistName);
if (dbArtist == null)
{
dbArtist = new VKSaverArtist
{
DbKey = artistName,
Name = artistName,
Tracks = new List <VKSaverTrack>(),
Albums = new List <VKSaverAlbum>()
};
await _database.InsertItem(dbArtist);
}
else if (dbAlbum != null)
{
dbArtist = await _database.GetItemWithChildrens <VKSaverArtist>(artistName);
}
else
{
dbArtist = null;
}
var dbGenre = await _database.FindItem <VKSaverGenre>(genreKey);
if (dbGenre == null)
{
dbGenre = new VKSaverGenre
{
DbKey = genreKey,
Name = genreKey,
Tracks = new List <VKSaverTrack>()
};
await _database.InsertItem(dbGenre);
}
else
{
dbGenre = null;
}
var dbVkInfo = await _database.FindItem <VKSaverAudioVKInfo>(vkInfoKey);
if (dbVkInfo == null)
{
dbVkInfo = audio.VK;
dbVkInfo.DbKey = vkInfoKey;
await _database.InsertItem(dbVkInfo);
}
else
{
dbVkInfo = null;
}
var track = new VKSaverTrack
{
Title = audio.Track.Title.Trim(),
Artist = artistName,
Duration = TimeSpan.FromTicks(audio.Track.Duration),
Source = MusicFilesPathHelper.GetCapatibleSource(filePath),
GenreKey = genreKey,
FolderKey = capatibleFolderPath,
AlbumKey = albumKey,
VKInfoKey = vkInfoKey
};
await _database.InsertItem(track);
if (dbAlbum != null)
{
dbAlbum.Tracks.Add(track);
await _database.UpdateItemChildrens(dbAlbum);
}
if (dbArtist != null)
{
if (dbAlbum != null)
{
dbArtist.Albums.Add(dbAlbum);
}
dbArtist.Tracks.Add(track);
await _database.UpdateItemChildrens(dbArtist);
}
if (dbFolder != null)
{
dbFolder.Tracks.Add(track);
await _database.UpdateItemChildrens(dbFolder);
}
if (dbGenre != null)
{
dbGenre.Tracks.Add(track);
await _database.UpdateItemChildrens(dbGenre);
}
if (dbVkInfo != null)
{
await _database.UpdateItemChildrens(dbVkInfo);
}
NeedReloadLibraryView = true;
}
public async void PlayTrackFromID(int trackID)
{
GC.Collect(1, GCCollectionMode.Forced);
if (!await HasTracks())
{
return;
}
ScrobbleTrack(CurrentTrack);
var track = _playlist[trackID];
CurrentTrack = track;
CurrentTrackID = trackID;
Debug.WriteLine($"Next track is: {track.Title}");
TrackChanged?.Invoke(this, new ManagerTrackChangedEventArgs(CurrentTrack, CurrentTrackID));
StorageFile file = await MusicFilesPathHelper.GetFileFromCapatibleName(track.Source);
bool skipMss = false;
if (file == null)
{
string vkInfoKey = $"{track.VKInfo.OwnerID} {track.VKInfo.ID}";
var dbTrack = await _database.FindItem <VKSaverTrack>(t => t.VKInfoKey == vkInfoKey);
if (dbTrack != null)
{
file = await MusicFilesPathHelper.GetFileFromCapatibleName(dbTrack.Source);
if (file != null)
{
skipMss = true;
}
}
}
if (!skipMss && (track.VKInfo != null || (file != null && file.Path.EndsWith(".vksm"))))
{
var worker = new MediaStreamSourceWorker(CurrentTrack, _musicCasheService, file);
var cachedSource = await worker.GetSource();
if (cachedSource != null)
{
Debug.WriteLine($"Cached track found: {track.Title}");
_player.SetMediaSource(cachedSource);
return;
}
else
{
worker.Dispose();
}
}
else if (file != null)
{
_player.SetFileSource(file);
return;
}
if (String.IsNullOrEmpty(track.Source))
{
NextTrack();
return;
}
_player.SetUriSource(new Uri(track.Source));
}
