public async Task IsCurrentPlaylingSong()
{
var song = new NetworkSong {
Title = "A"
};
var playlist = new NetworkPlaylist
{
Name = "A",
Songs = new List <NetworkSong> {
song
}.AsReadOnly(),
CurrentIndex = 0
};
var messenger = CreateDefaultPlaylistMessenger();
messenger.GetCurrentPlaylistAsync().Returns(playlist.ToTaskResult());
var vm = new PlaylistViewModel();
vm.Activator.Activate();
await vm.LoadPlaylistCommand.ExecuteAsync();
Assert.Equal("A", vm.CurrentSong.Title);
}
public async Task <FileTransferStatus> QueueRemoteSong(LocalSong songMetadata, byte[] songData)
{
var song = new NetworkSong
{
Album = songMetadata.Album,
Artist = songMetadata.Artist,
Duration = songMetadata.Duration,
Genre = songMetadata.Genre,
Source = NetworkSongSource.Mobile,
Title = songMetadata.Title,
Guid = Guid.NewGuid()
};
Guid transferId = Guid.NewGuid();
var info = new SongTransferInfo
{
TransferId = transferId,
Metadata = song
};
ResponseInfo response = await this.SendRequest(RequestAction.QueueRemoteSong, info);
var message = new SongTransferMessage {
Data = songData, TransferId = transferId
};
var progress = this.TransferFileAsync(message).Publish(0);
progress.Connect();
var status = new FileTransferStatus(response, progress);
return(status);
}
internal static MobileSong Create(NetworkSong metaData, IObservable <byte[]> data, IFileSystem fileSystem = null)
{
fileSystem = fileSystem ?? new FileSystem();
string tempPath = fileSystem.Path.GetTempFileName();
// Lol, MediaElement is too stupid to play a file with a .tmp extension
string newName = Path.ChangeExtension(tempPath, ".mp3");
fileSystem.File.Move(tempPath, newName);
tempPath = newName;
var song = new MobileSong(tempPath, metaData.Duration)
{
Album = metaData.Album,
Artist = metaData.Artist,
Genre = metaData.Genre,
Title = metaData.Title
};
var conn = data.FirstAsync()
.Do(x => fileSystem.File.WriteAllBytes(tempPath, x))
.ToUnit()
.Multicast(song.dataGate);
conn.Connect();
return(song);
}
private static NetworkSong SetupSongWithArtist(string artist)
{
NetworkSong song = Helpers.SetupSong();
song.Artist = artist;
return(new LocalSong(song.Title, song.Artist, song.Album, song.Genre, song.Duration, 0, "0"));
}
public RemoteSongViewModel(NetworkSong model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
}
public void CreatesEmptyTemporaryFile()
{
var fileSystem = new MockFileSystem();
var metadata = new NetworkSong();
var song = MobileSong.Create(metadata, Observable.Never <byte[]>(), fileSystem);
Assert.Equal(0, fileSystem.FileInfo.FromFileName(song.PlaybackPath).Length);
}
public void StoresDataUponArrival()
{
var fileSystem = new MockFileSystem();
var metadata = new NetworkSong();
var data = new byte[] { 0, 1 };
var song = MobileSong.Create(metadata, Observable.Return(data), fileSystem);
Assert.Equal(data, fileSystem.File.ReadAllBytes(song.PlaybackPath));
}
public PlaylistEntryViewModel(NetworkSong song, bool isVoteable, bool isPlaying = false)
{
if (song == null)
{
throw new ArgumentNullException("song");
}
this.song = song;
this.IsVoteAble = isVoteable;
this.isPlayling = isPlaying;
}
public void SetsTemporaryFileAsSongPath()
{
var fileSystem = new MockFileSystem();
var metadata = new NetworkSong();
var song = MobileSong.Create(metadata, Observable.Never <byte[]>(), fileSystem);
DirectoryInfoBase tempDir = fileSystem.DirectoryInfo.FromDirectoryName(fileSystem.Path.GetTempPath());
Assert.Equal(song.OriginalPath, tempDir.GetFiles().First().FullName);
Assert.Equal(song.PlaybackPath, tempDir.GetFiles().First().FullName);
}
public YoutubeSongViewModel(NetworkSong model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
this.artwork = ArtworkHelper.LoadArtwork(model)
.LoggedCatch(this, null, "Failed to load YouTube artwork")
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.Artwork);
var connectArtwork = this.Artwork;
}
private void WaitsForSongData()
{
var metadata = new NetworkSong();
var data = new Subject <byte[]>();
var song = MobileSong.Create(metadata, data, new MockFileSystem());
Task awaiter = song.PrepareAsync(YoutubeStreamingQuality.Low);
Assert.False(awaiter.IsCompleted);
data.OnNext(new byte[] { 0, 1 });
data.OnCompleted();
Assert.True(awaiter.IsCompleted);
}
public static IObservable <IBitmap> LoadArtwork(NetworkSong song)
{
if (song.ArtworkKey == null)
{
return(Observable.Return((IBitmap)null));
}
return(BlobCache.LocalMachine.GetOrFetchObject(song.ArtworkKey, () => GetData(song.ArtworkKey), DateTimeOffset.Now + TimeSpan.FromDays(1))
.SelectMany(async imageData =>
{
using (var stream = new MemoryStream(imageData))
{
return await BitmapLoader.Current.Load(stream, null, null);
}
}));
}
