public PlaylistWithAudio(AudioPlaylist playlist, IReadOnlyList <Audio> audio)
{
Playlist = playlist;
Audio = audio
.OrderBy(a => a.Date)
.ToList();
}
public PageGetter <Audio> AudiosInPlaylist(AudioPlaylist playlist) => async(count, offset) => await vkApi.Audio.GetAsync(new AudioGetParams()
{
OwnerId = playlist.OwnerId.Value,
AlbumId = playlist.Id.Value,
Count = (long)count,
Offset = (long)offset
});
public async Task <PlaylistWithAudio> ExpandPlaylist(AudioPlaylist playlist, CancellationToken token, ILog log)
{
var audios = await GetAllPagesAsync(AudiosInPlaylist(playlist), long.MaxValue, token, log, true);
log.Debug($"Expanded playlist {playlist.Title}: {audios.Count} audios");
return(new PlaylistWithAudio(playlist, audios));
}
/// <summary>
/// Play audio with playlist
/// </summary>
public void PlayAudio(IAudio audio, IList <IAudio> sourcePlaylist)
{
//check if it's a new playlist
if (!_currentPlaylist.Items.AreSame(sourcePlaylist))
{
_currentPlaylist.OnCurrentItemChanged -= CurrentPlaylistOnCurrentItemChanged;
var shuffle = Shuffle;
var repeat = Repeat;
_currentPlaylist = new AudioPlaylist(sourcePlaylist);
_currentPlaylist.Repeat = repeat;
_currentPlaylist.Shuffle = shuffle;
_currentPlaylist.CurrentItem = audio;
_currentPlaylist.OnCurrentItemChanged += CurrentPlaylistOnCurrentItemChanged;
CurrentPlaylistOnCurrentItemChanged(this, audio);
}
else
{
if (_currentPlaylist.CurrentItem == audio)
{
PlayFrom(_currentPlaylist.CurrentItem.Source);
}
else
{
_currentPlaylist.CurrentItem = audio;
}
}
}
private void CreateAndAddAudio(PlayCatDbContext context, Guid playlistId, int count)
{
if (count < -0)
{
return;
}
for (int i = 0; i < count; i++)
{
DataModels.Audio audio = context.CreateAudio(DateTime.Now.AddMinutes(i), "access" + i, "artist" + i, "song" + i, BaseAudioExtension, i.ToString(), i.ToString(), null);
AudioPlaylist audioPlaylist = context.CreateAudioPlaylist(DateTime.Now.AddMinutes(i), audio.Id, playlistId, i);
}
}
public AudioPlaylistTests()
{
_musicLibrary = A.Fake <IMusicLibrary>();
_mediaPlayer = A.Fake <IMediaPlayer>();
A.CallTo(() => _mediaPlayer.LoadFile(A <string> .Ignored, A <MediaPlayerMetadata> .Ignored)).Invokes((o) => _mediaPlayer.Playing = true);
_audioPlaylist = new AudioPlaylist(_musicLibrary, _mediaPlayer);
_track = A.Fake <ITrack>();
A.CallTo(() => _track.Song).Returns(new Song {
FileName = TrackFileName
});
_audioPlaylist.Tracks.Add(_track);
}
public static AudioPlaylist ToAudioPlaylist(this PlaylistFile source, AudioFile fileNow)
{
var audioPlaylist = new AudioPlaylist()
{
Shuffle = false,
Cover = source.Cover,
CurrentItem = fileNow,
Id = source.Id,
Items = source.TracksFiles.Count != 0 ? source.TracksFiles : new List <AudioFile>(),
Repeat = Enums.RepeatMode.None,
Artist = source.Artist,
Name = source.Name
};
return(audioPlaylist);
}
public static AudioPlaylist ToAudioPlaylist(this PlaylistFile source)
{
var audioPlaylist = new AudioPlaylist()
{
Shuffle = StaticContent.Shuffle,
Cover = source.Cover,
CurrentItem = source.TracksFiles.Count != 0? source.TracksFiles[0]: null,
Id = source.Id,
Items = source.TracksFiles.Count != 0 ? source.TracksFiles: new List <AudioFile>(),
Repeat = StaticContent.Repeat,
Artist = source.Artist,
Name = source.Name
};
return(audioPlaylist);
}
// Constructor
public NAudioComponent()
{
CurrentVolume = 0.5f;
Playlist = new AudioPlaylist();
Playlist.InitPlaylist(_filePath);
if (AudioFile == null)
{
AudioFile = new AudioFileReader(Playlist.Songs[Playlist.Index])
{
Volume = CurrentVolume
};
}
if (OutputDevice == null)
{
OutputDevice = new WaveOutEvent();
OutputDevice.PlaybackStopped += OnPlaybackStopped;
OutputDevice.Init(AudioFile);
}
}
/// <summary>
/// Sets current playlist. Used to update UI on the first data load.
/// </summary>
public void SetCurrentPlaylist(AudioPlaylist playlist)
{
if (_currentPlaylist != null)
{
_currentPlaylist.OnCurrentItemChanged -= CurrentPlaylistOnCurrentItemChanged;
}
_currentPlaylist = playlist;
if (_currentPlaylist != null)
{
_currentPlaylist.Repeat = Repeat;
_currentPlaylist.Shuffle = Shuffle;
_currentPlaylist.OnCurrentItemChanged += CurrentPlaylistOnCurrentItemChanged;
CurrentAudioChanged?.Invoke(this, EventArgs.Empty);
}
}
public BaseResult AddToPlaylist(Guid userId, AddRemovePlaylistRequest request)
{
return(BaseInvokeWithTransaction(() =>
{
//Is need check audioId??? - perfomance issue
var playlistInfo =
(from p in _dbContext.Playlists.Include(x => x.AudioPlaylists)
where p.Id == request.PlaylistId && p.OwnerId == userId
select new
{
Playlist = p,
IsAlreadyAdded = p.AudioPlaylists.Any(x => x.AudioId == request.AudioId)
})
.FirstOrDefault();
if (playlistInfo == null)
{
return ResponseBuilder <BaseResult> .Fail().SetInfoAndBuild("Playlist not found");
}
if (playlistInfo.IsAlreadyAdded)
{
return ResponseBuilder <BaseResult> .Fail().SetInfoAndBuild("Audio is already added");
}
var audioPlaylist = new AudioPlaylist
{
AudioId = request.AudioId,
DateCreated = DateTime.Now,
Order = playlistInfo.Playlist.OrderValue,
PlaylistId = request.PlaylistId
};
playlistInfo.Playlist.OrderValue++;
_dbContext.Entry(playlistInfo.Playlist).State = EntityState.Modified;
_dbContext.AudioPlaylists.Add(audioPlaylist);
_dbContext.SaveChanges();
return ResponseBuilder <BaseResult> .SuccessBuild();
}));
}
/// <summary>
/// Поулчить треки из плейлиста
/// </summary>
/// <param name="pl"></param>
/// <param name="api"></param>
/// <returns></returns>
public static Track[] GetPlaylist(AudioPlaylist pl, VkApi api)
{
TextConsole.PrintConsole.Header($"Получение треков из плейлиста: {pl.Title}");
try
{
var audios = api.Audio.Get(new AudioGetParams()
{
OwnerId = pl.Original.OwnerId,
PlaylistId = pl.Original.PlaylistId,
AccessKey = pl.AccessKey
});
return(ToList(audios));
}
catch (Exception ex)
{
if (ex.GetType() == typeof(VkNet.Exception.CannotBlacklistYourselfException))
{
TextConsole.PrintConsole.Print($"Не удаётся получить доступ к плейлисту: [{pl.Title}]", TextConsole.MenuType.Warning);
}
return(null);
}
}
public void Play(PlaylistFile playlist = null, AudioFile audio = null)
{
//EndsWith(".mp3")
if (audio.SourceString.Split("//")[1].Split("/")[0].EndsWith(".mp3"))
{
Toast.MakeText(Application.Context, "URI трека пришел с ошибкой. Невозможно воспроизвести.", ToastLength.Long).Show();
return;
}
if (playlist == null)
{
if (currentPlaylist == null && currentTrack == null)
{
return;
}
player.Play();
}
else
{
if (playlist.Id != currentPlaylistId)
{
var audioPlaylist = new AudioPlaylist(playlist, audio, StaticContentService.RepeatPlaylist, StaticContentService.RepeatTrack);
currentPlaylist = audioPlaylist;
currentTrack = audio;
currentPlaylist.OnCurrentItemChanged += CurrentPlaylistOnOnCurrentItemChanged;
CurrentAudioChanged?.Invoke(this, audio);
}
else
{
currentPlaylist.SetCurrentTrack(audio);
currentTrack = audio;
CurrentAudioChanged?.Invoke(this, audio);
}
//var playerNotificationManager = (CrossMediaManager.Android.NotificationManager as MediaManager.Platforms.Android.Notifications.NotificationManager).PlayerNotificationManager;
TaskService.RunOnUI(async() =>
{
Toast.MakeText(Application.Context, "[Отладка] Начинаем воспроизводить...", ToastLength.Long).Show();
Toast.MakeText(Application.Context, $"[Отладка] URI: {currentTrack.SourceString}", ToastLength.Long).Show();
var media = await player.Play(currentTrack.SourceString);
media.Title = currentTrack.Title;
media.AlbumArtUri = ""; //Без этого треки с битыми ссылками будут выкидывать плеер в фатал
media.Artist = currentTrack.Artist;
media.AlbumArtist = currentTrack.Artist;
media.ArtUri = null;
if (currentTrack.Cover != "placeholder")
{
media.ArtUri = currentTrack.Cover;
}
CrossMediaManager.Android.NotificationManager.UpdateNotification();
});
//player.MediaQueue.Current.Title = audio.Title;
//player.MediaQueue.Current.Artist = audio.Title;
//player.MediaQueue.Current.AlbumArtUri = audio.Cover;
//CrossMediaManager.Android.
//player.NotificationManager = null;
}
}
public async Task <UploadResult> UploadAudioAsync(Guid userId, UploadAudioRequest request)
{
return(await BaseInvokeCheckModelAsync(request, async() =>
{
User user = _dbContext.Users.FirstOrDefault(x => x.Id == userId);
if (user == null)
{
throw new Exception("User not found, but token does");
}
var responseBuilder =
ResponseBuilder <UploadResult>
.Fail();
if (user.IsUploadingAudio)
{
return responseBuilder.SetInfoAndBuild("User already uploading audio");
}
user.IsUploadingAudio = true;
_dbContext.SaveChanges();
using (var transaction = _dbContext.Database.BeginTransaction())
{
try
{
GetInfoResult result = await GetInfoAsync(new UrlRequest {
Url = request.Url
});
if (!result.Ok)
{
return responseBuilder
.SetErrors(result.Errors)
.SetInfoAndBuild(result.Info);
}
string videoId = UrlFormatter.GetYoutubeVideoIdentifier(request.Url);
IFile videoFile = await _saveVideo.SaveAsync(request.Url);
IFile audioFile = await _extractAudio.ExtractAsync(videoFile);
//TODO: create upload for FileSystem, Blob, etc...
string accessUrl = _uploadAudio.Upload(audioFile, StorageType.FileSystem);
var generalPlayList = _dbContext.Playlists.FirstOrDefault(x => x.OwnerId == userId && x.IsGeneral);
if (generalPlayList == null)
{
throw new Exception("Playlist not found");
}
var audio = new Audio
{
Id = Guid.NewGuid(),
AccessUrl = accessUrl,
DateCreated = DateTime.Now,
Artist = request.Artist,
Song = request.Song,
Duration = audioFile.Duration,
Extension = audioFile.Extension,
FileName = audioFile.Filename,
UniqueIdentifier = videoId,
UploaderId = userId
};
var audioPlaylist = new AudioPlaylist
{
AudioId = audio.Id,
DateCreated = DateTime.Now,
PlaylistId = generalPlayList.Id,
Order = generalPlayList.OrderValue
};
//update max index in playlist
generalPlayList.OrderValue++;
//add entities
_dbContext.AudioPlaylists.Add(audioPlaylist);
Audio audioEntity = _dbContext.Audios.Add(audio).Entity;
_dbContext.SaveChanges();
transaction.Commit();
return ResponseBuilder <UploadResult> .SuccessBuild(new UploadResult
{
Audio = AudioMapper.ToApi.FromData(audioEntity)
});
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
finally
{
//skip upload process
user.IsUploadingAudio = false;
_dbContext.SaveChanges();
}
}
}));
}
public static IPlaylistFile ToIPlaylistFile(this AudioPlaylist playlist, IList <IAudioFile> tracks)
{
bool isAlbum = playlist.Type == 1;
string cover;
string artist = "";
string genre = "";
string year = "";
string description = "";
try
{
artist = playlist.MainArtists.First().Name;
}
catch
{
artist = "Неизвестный исполнитель";
}
try
{
cover = playlist.Cover.Photo300;
}
catch
{
cover = "no";
}
if (isAlbum)
{
try
{
genre = playlist.Genres.First().Name;
}
catch
{
genre = "no";
}
try
{
year = playlist.Year.Value.ToString();
}
catch
{
year = "no";
}
}
else
{
if (playlist.Description != null)
{
description = playlist.Description;
}
genre = "no";
year = "no";
}
IPlaylistFile playlistFile = new PlaylistFileAnyPlatform()
{
Artist = artist,
Cover = cover,
Id = playlist.Id.Value,
IsLocal = false,
Tracks = tracks,
Name = playlist.Title,
AccessKey = playlist.AccessKey,
IsAlbum = isAlbum,
OnRequest = tracks.Count == 0,
Plays = playlist.Plays,
OwnerId = playlist.OwnerId.Value,
Genre = genre,
Year = year,
Description = description
};
return(playlistFile);
}
