private void SetTracklist(Tracklist t)
{
this.tracklist = t;
TracklistEntry[] entries = tracklist.entries;
EventTracklistEntry entry;
TracklistEntry nextEntry;
for (int k = 0; k < entries.Length; k++)
{
entry = (EventTracklistEntry)entries [k];
if (entry is LoopingTracklistEntry)
{
LoopingTrack loopingTrack = (LoopingTrack)entry.GetTrack();
entry.AddStateEventAtTimeRemaining(LoopCurrentTrack, loopingTrack.crossoverTime);
}
else if (k < entries.Length - 1)
{
nextEntry = entries [k + 1];
entry.AddStateEventAtTimeRemaining(PlayNextTrack, nextEntry.GetTrack().EntranceFadeTime());
}
// entry.AddStateEventAtTime (UnloadPreviousTrack, 4f);
// entry.AddStateEventAtTime (LoadNextTrack, 5f);
}
#if !UNITY_EDITOR
((MobileVideoPlayer)videoSystem.GetPlayer()).InitialiseMobileVideoTracksInList(tracklist);
#endif
}
private void ContructUIFromTracklist(Tracklist tl)
{
for (int k = 0; k < tl.entries.Length; k++)
{
AddListItem(tl.entries [k]);
}
}
public async Task GetLengthTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Tracklist.GetLength();
Assert.True(res2.Succeeded);
Assert.Equal(0, res2.Result);
var res3 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res3.Succeeded);
Assert.True(1 <= res3.Result.Length);
Assert.True(1 <= res3.Result.First().Tracks.Length);
var uris = res3.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res4 = await Tracklist.Add(uris);
Assert.True(res4.Succeeded);
var res5 = await Tracklist.GetLength();
Assert.True(res5.Succeeded);
Assert.Equal(uris.Length, res5.Result);
}
public async Task IndexTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
var res4 = await Tracklist.GetTlTracks();
Assert.True(res4.Succeeded);
Assert.Equal(uris.Length, res4.Result.Length);
for (var i = 0; i < uris.Length; i++)
{
var res5 = await Tracklist.Index(tlId : res4.Result[i].TlId);
Assert.Equal(uris[(int)res5.Result], res4.Result[i].Track.Uri);
}
}
private void DayPanel_DoubleClick(object sender, EventArgs e)
{
using (Tracklist dlg = new Tracklist())
{
dlg.ShowDialog();
}
}
public TrackStore(
[FromServices] Dbc dbc,
[FromServices] Tracklist tracklist,
[FromServices] Playback playback
) : base(dbc)
{
this._tracklist = tracklist;
this._playback = playback;
}
public async Task GetCurrentTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
var res4 = await Playback.GetState();
Assert.True(res4.Succeeded);
if (res4.Result != PlaybackState.Stopped)
{
var res5 = await Playback.Stop();
Assert.True(res5);
}
await Task.Delay(PlaybackTest.WaitMsec);
var res6 = await Playback.Play(res3.Result[4].TlId);
Assert.True(res6);
await Task.Delay(PlaybackTest.WaitMsec);
var res7 = await Playback.GetCurrentTlTrack();
Assert.True(res7.Succeeded);
Assert.Equal(res7.Result.TlId, res3.Result[4].TlId);
Assert.Equal(res7.Result.Track.Uri, res3.Result[4].Track.Uri);
var res8 = await Playback.GetCurrentTrack();
Assert.True(res8.Succeeded);
Assert.Equal(res8.Result.Uri, res3.Result[4].Track.Uri);
//var res9 = await Playback.GetStreamTitle();
//Assert.True(res9.Succeeded);
//Assert.Equal(res3.Result[4].Track.Name, res9.Result);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
this._playback = null;
this._tracklist = null;
}
base.Dispose(disposing);
}
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
Tracklist model = base.BindModel(controllerContext, bindingContext) as Tracklist;
model.Collection.RemoveEmptyItems();
if (model.IsEmpty)
{
return(null);
}
return(model);
}
public async Task GetPreviousTlIdTest()
{
var res = await Tracklist.GetPreviousTlId();
Assert.True(res.Succeeded);
if (res.Result != null)
{
Assert.True(0 <= res.Result);
}
}
private void SetTracks(SpotifyUser user, SpotifyPlaylist createdPlaylist, Tracklist tracklist)
{
var request = new HttpRequestMessage(HttpMethod.Put, $"/v1/users/{user.Id}/playlists/{createdPlaylist.Id}/tracks")
{
Content = new StringContent(JsonConvert.SerializeObject(tracklist),
Encoding.UTF8,
"application/json")
};
var response = _client.SendAsync(request).Result;
}
public async Task SliceTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
Assert.Equal(uris.Length, res3.Result.Length);
var sliced = new string[]
{
uris[5],
uris[6],
uris[7],
uris[8],
};
var res4 = await Tracklist.Slice(5, 9);
Assert.True(res4.Succeeded);
Assert.Equal(4, res4.Result.Length);
for (var i = 0; i < sliced.Length; i++)
{
Assert.Equal(sliced[i], res4.Result[i].Track.Uri);
}
var res5 = await Tracklist.GetTlTracks();
Assert.True(res5.Succeeded);
Assert.Equal(uris.Length, res5.Result.Length);
for (var i = 0; i < uris.Length; i++)
{
Assert.Equal(uris[i], res5.Result[i].Track.Uri);
}
}
public async Task MoveTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res4 = await Tracklist.Add(uris);
Assert.True(res4.Succeeded);
// 2-3 -> index 5
var res5 = await Tracklist.Move(2, 4, 5);
var moved = new string[]
{
uris[0],
uris[1],
uris[4],
uris[5],
uris[6],
uris[2],
uris[3],
uris[7],
uris[8],
uris[9],
uris[10]
};
var res6 = await Tracklist.GetTlTracks();
Assert.True(res6.Succeeded);
Assert.Equal(moved.Length, res6.Result.Length);
for (var i = 0; i < moved.Length; i++)
{
Assert.Equal(moved[i], res6.Result[i].Track.Uri);
}
}
public async Task SetSingleTest()
{
var res1 = await Tracklist.GetSingle();
Assert.True(res1.Succeeded);
var res2 = await Tracklist.SetSingle(!res1.Result);
Assert.True(res2);
var res3 = await Tracklist.GetSingle();
Assert.True(res3.Succeeded);
Assert.True(res1.Result != res3.Result);
}
public void AddTrack(bool closeTagSpace = true)
{
if (curTrackIndex == null)
{
throw new TrackIndexException("Can't add track without StartTime");
}
var tags = _tagSpaceManager.TagSpaces.Peek().Tags;
Tracklist.Add(new Track(curTrackIndex, tags));
curTrackIndex = null;
if (closeTagSpace)
{
_tagSpaceManager.CloseTagSpace();
}
}
public string CreatePlaylist(TokenResponse token, PlaylistResult playlist)
{
_client.DefaultRequestHeaders.Add("Authorization", $"Bearer {token.AccessToken}");
var user = GetUser();
_requestLogger.LogSpotify(user, playlist, token);
var createdPlaylist = CreateNew(user, playlist.ArtistName);
var tracklist = new Tracklist {
Uris = new List <String>()
};
foreach (var song in playlist.Songs)
{
try
{
tracklist.Uris.Add(GetTrack(playlist.ArtistName, song.Name).Uri);
}
catch (Exception)
{
try
{
foreach (var songName in song.Name.Split("/"))
{
tracklist.Uris.Add(GetTrack(playlist.ArtistName, songName.Trim()).Uri);
}
}
catch (Exception)
{
}
}
}
SetTracks(user, createdPlaylist, tracklist);
return(createdPlaylist.ExternalUrls.Spotify);
}
public void InitialiseMobileVideoTracksInList(Tracklist list)
{
TracklistEntry entry;
for (int k = 0; k < list.entries.Length; k++)
{
entry = list.entries[k];
if (entry is VideoTracklistEntry)
{
if (controlsIndex < controls.Length)
{
((MobileVideoTrack)entry.GetTrack()).SetControls(controls [controlsIndex]);
Diglbug.LogMobile("AssignControl:" + controlsIndex, "ODD_2");
controlsIndex++;
}
else
{
Diglbug.LogError("Tried to assign a video track with insufficient slots. Please add more Controllers");
}
}
}
}
public async Task ShuffleTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
var ordered = new Dictionary <int, string>()
{
{ 0, uris[0] },
{ 1, uris[1] },
{ 2, uris[2] },
{ 3, uris[3] },
{ 4, uris[4] },
{ 10, uris[10] }
};
var unordered = new Dictionary <int, string>()
{
{ 5, uris[5] },
{ 6, uris[6] },
{ 7, uris[7] },
{ 8, uris[8] },
{ 9, uris[9] },
};
var res4 = await Tracklist.Shuffle(5, 10);
Assert.True(res4);
var res5 = await Tracklist.GetTlTracks();
Assert.True(res5.Succeeded);
Assert.Equal(uris.Length, res5.Result.Length);
foreach (var pair in ordered)
{
Assert.Equal(ordered[pair.Key], res5.Result[pair.Key].Track.Uri);
}
var shuffled = false;
foreach (var pair in unordered)
{
if (pair.Value != res5.Result[pair.Key].Track.Uri)
{
shuffled = true;
break;
}
}
Assert.True(shuffled);
}
public async Task GetSingleTest()
{
var res = await Tracklist.GetSingle();
Assert.True(res.Succeeded);
}
public async Task GetRepeatTest()
{
var res = await Tracklist.GetRepeat();
Assert.True(res.Succeeded);
}
public static async Task IncreaseViewCountUpdateHistory(int trackId)
{
var thisTrack = await _trackService.GetById <Track>(trackId);
var res = await _tracklistService.Get <List <Tracklist> >(new TracklistSearchRequest()
{
TracklistName = "History",
UserId = APIService.loggedProfile.UserId
});
Tracklist history = res.FirstOrDefault();
var res1 = await _tracklistTrackService.Get <List <TracklistTrack> >(new TracklistTrackSearchRequest()
{
TrackId = trackId,
TracklistId = history.TracklistId
});
if (res1.Count == 0)
{
await _tracklistTrackService.Insert <TracklistTrack>(new TracklistTrackUpsertRequest()
{
TracklistId = history.TracklistId,
DateAdded = DateTime.Now,
TrackId = trackId
});
await _trackService.Update <Track>(trackId, new TrackUpsertRequest()
{
AlbumId = thisTrack.AlbumId,
TrackLyrics = thisTrack.TrackLyrics,
TrackName = thisTrack.TrackName,
TrackNumber = thisTrack.TrackNumber,
TrackViews = thisTrack.TrackViews + 1,
TrackYoutubeId = thisTrack.TrackYoutubeId
});
}
else
{
TimeSpan diff = (TimeSpan)(DateTime.Now - res1.FirstOrDefault().DateAdded);
await _tracklistTrackService.Update <TracklistTrack>(0, new TracklistTrackUpsertRequest()
{
DateAdded = DateTime.Now,
TrackId = trackId,
TracklistId = history.TracklistId
});
await _tracklistTrackService.Insert <TracklistTrack>(new TracklistTrackUpsertRequest()
{
DateAdded = DateTime.Now,
TrackId = trackId,
TracklistId = history.TracklistId
});
if (diff.Days != 0)
{
await _trackService.Update <Track>(trackId, new TrackUpsertRequest()
{
AlbumId = thisTrack.AlbumId,
TrackLyrics = thisTrack.TrackLyrics,
TrackName = thisTrack.TrackName,
TrackNumber = thisTrack.TrackNumber,
TrackViews = thisTrack.TrackViews + 1,
TrackYoutubeId = thisTrack.TrackYoutubeId
});
}
}
}
public async Task FilterTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
Assert.Equal(uris.Length, res3.Result.Length);
var filtered1 = new string[]
{
uris[1],
uris[3],
uris[5],
uris[7],
};
var criteria = new Tracklist.Criteria();
criteria.TlId.Add(res3.Result[1].TlId);
criteria.TlId.Add(res3.Result[3].TlId);
criteria.TlId.Add(res3.Result[5].TlId);
criteria.TlId.Add(res3.Result[7].TlId);
//criteria.Uri.Add("local:track:");
var res4 = await Tracklist.Filter(criteria);
Assert.True(res4.Succeeded);
Assert.Equal(filtered1.Length, res4.Result.Length);
for (var i = 0; i < filtered1.Length; i++)
{
Assert.Equal(filtered1[i], res4.Result[i].Track.Uri);
}
criteria.Clear();
criteria.Uri.Add(res3.Result[1].Track.Uri);
criteria.Uri.Add(res3.Result[3].Track.Uri);
criteria.Uri.Add(res3.Result[5].Track.Uri);
criteria.Uri.Add(res3.Result[7].Track.Uri);
var res5 = await Tracklist.Filter(criteria);
Assert.True(res5.Succeeded);
Assert.Equal(filtered1.Length, res5.Result.Length);
for (var i = 0; i < filtered1.Length; i++)
{
Assert.Equal(filtered1[i], res5.Result[i].Track.Uri);
}
var res6 = await Tracklist.Filter(tlId : new int[]
{
res3.Result[1].TlId,
res3.Result[3].TlId,
res3.Result[5].TlId,
res3.Result[7].TlId,
});
Assert.True(res6.Succeeded);
Assert.Equal(filtered1.Length, res6.Result.Length);
for (var i = 0; i < filtered1.Length; i++)
{
Assert.Equal(filtered1[i], res6.Result[i].Track.Uri);
}
var res7 = await Tracklist.Filter(uri : new string[]
{
res3.Result[1].Track.Uri,
res3.Result[3].Track.Uri,
res3.Result[5].Track.Uri,
res3.Result[7].Track.Uri,
});
Assert.True(res7.Succeeded);
Assert.Equal(filtered1.Length, res7.Result.Length);
for (var i = 0; i < filtered1.Length; i++)
{
Assert.Equal(filtered1[i], res7.Result[i].Track.Uri);
}
var res8 = await Tracklist.Filter(tlId : res3.Result[1].TlId);
Assert.True(res8.Succeeded);
Assert.Single(res8.Result);
Assert.Equal(res3.Result[1].Track.Uri, res8.Result[0].Track.Uri);
var res9 = await Tracklist.Filter(uri : res3.Result[3].Track.Uri);
Assert.True(res9.Succeeded);
Assert.Single(res9.Result);
Assert.Equal(res3.Result[3].TlId, res9.Result[0].TlId);
var res10 = await Tracklist.GetTlTracks();
Assert.True(res10.Succeeded);
Assert.Equal(uris.Length, res10.Result.Length);
for (var i = 0; i < uris.Length; i++)
{
Assert.Equal(uris[i], res10.Result[i].Track.Uri);
}
}
public async Task PlaybackStateChangedTest()
{
if (Mopidy.Settings.ConnectionType != Mopidy.Settings.Connection.WebSocket)
{
return;
}
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
var res4 = await Playback.GetState();
Assert.True(res4.Succeeded);
var beforeState = res4.Result;
var recieved = false;
var matchedOld = false;
var changedNew = false;
CoreListener.PlaybackStateChanged += (sender, ev) =>
{
recieved = true;
if (beforeState == ev.OldState)
{
matchedOld = true;
}
if (beforeState != ev.NewState)
{
changedNew = true;
}
};
if (res4.Result != Mopidy.Models.Enums.PlaybackState.Playing)
{
var res5 = await Playback.Play(res3.Result[4].TlId);
Assert.True(res5);
await Task.Delay(WaitMsec);
Assert.True(recieved);
Assert.True(matchedOld);
Assert.True(changedNew);
}
beforeState = Mopidy.Models.Enums.PlaybackState.Playing;
recieved = false;
matchedOld = false;
changedNew = false;
var res6 = await Playback.Pause();
Assert.True(res6);
await Task.Delay(WaitMsec);
Assert.True(recieved);
Assert.True(matchedOld);
Assert.True(changedNew);
beforeState = Mopidy.Models.Enums.PlaybackState.Paused;
recieved = false;
matchedOld = false;
changedNew = false;
var res7 = await Playback.Stop();
Assert.True(res7);
await Task.Delay(WaitMsec);
Assert.True(recieved);
Assert.True(matchedOld);
Assert.True(changedNew);
beforeState = Mopidy.Models.Enums.PlaybackState.Stopped;
recieved = false;
matchedOld = false;
changedNew = false;
var res8 = await Playback.Play();
Assert.True(res8);
await Task.Delay(WaitMsec);
Assert.True(recieved);
Assert.True(matchedOld);
Assert.True(changedNew);
}
public async Task TracklistEventTest()
{
if (Mopidy.Settings.ConnectionType != Mopidy.Settings.Connection.WebSocket)
{
return;
}
var seeked = false;
var seekedCount = 0;
var tracklistChanged = false;
var trackPlaybackStarted = false;
var trackPlaybackPaused = false;
var trackPlaybackResumed = false;
var trackPlaybackEnded = false;
CoreListener.Seeked += (sender, ev) =>
{
seeked = true;
seekedCount++;
Assert.NotNull(ev);
Assert.True(0 <= ev.TimePosition);
};
CoreListener.StreamTitleChanged += (sender, ev) =>
{
Assert.NotNull(ev);
Assert.NotNull(ev.Title);
};
CoreListener.TracklistChanged += (sender, ev) =>
{
tracklistChanged = true;
Assert.NotNull(ev);
};
CoreListener.TrackPlaybackStarted += (sender, ev) =>
{
trackPlaybackStarted = true;
Assert.NotNull(ev);
Assert.NotNull(ev.TlTrack);
Assert.True(0 <= ev.TlTrack.TlId);
Assert.NotNull(ev.TlTrack.Track);
};
CoreListener.TrackPlaybackPaused += (sender, ev) =>
{
trackPlaybackPaused = true;
Assert.NotNull(ev);
Assert.NotNull(ev.TlTrack);
Assert.True(0 <= ev.TlTrack.TlId);
Assert.NotNull(ev.TlTrack.Track);
Assert.True(0 <= ev.TimePosition);
};
CoreListener.TrackPlaybackResumed += (sender, ev) =>
{
trackPlaybackResumed = true;
Assert.NotNull(ev);
Assert.NotNull(ev.TlTrack);
Assert.True(0 <= ev.TlTrack.TlId);
Assert.NotNull(ev.TlTrack.Track);
Assert.True(0 <= ev.TimePosition);
};
CoreListener.TrackPlaybackEnded += (sender, ev) =>
{
trackPlaybackEnded = true;
Assert.NotNull(ev);
Assert.NotNull(ev.TlTrack);
Assert.True(0 <= ev.TlTrack.TlId);
Assert.NotNull(ev.TlTrack.Track);
Assert.True(0 <= ev.TimePosition);
};
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
tracklistChanged = false;
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
await Task.Delay(WaitMsec);
Assert.True(tracklistChanged);
trackPlaybackStarted = false;
var res4 = await Playback.Play(res3.Result[4].TlId);
Assert.True(res4);
await Task.Delay(WaitMsec);
Assert.True(trackPlaybackStarted);
trackPlaybackPaused = false;
var res5 = await Playback.Pause();
Assert.True(res5);
await Task.Delay(WaitMsec);
Assert.True(trackPlaybackPaused);
trackPlaybackResumed = false;
var res6 = await Playback.Resume();
Assert.True(res5);
await Task.Delay(WaitMsec);
Assert.True(trackPlaybackResumed);
seeked = false;
trackPlaybackEnded = false;
var res7 = await Playback.Seek((int)res3.Result[4].Track.Length - 1000);
await Task.Delay((int)(WaitMsec * 2.1));
Assert.True(seeked);
Assert.True(trackPlaybackEnded);
Assert.True(0 <= seekedCount);
}
public async Task OptionsChangedTest()
{
if (Mopidy.Settings.ConnectionType != Mopidy.Settings.Connection.WebSocket)
{
return;
}
var res1 = await Tracklist.GetConsume();
Assert.True(res1.Succeeded);
var res2 = await Tracklist.GetRandom();
Assert.True(res2.Succeeded);
var res3 = await Tracklist.GetRepeat();
Assert.True(res3.Succeeded);
var res4 = await Tracklist.GetSingle();
Assert.True(res4.Succeeded);
var recieved = false;
CoreListener.OptionsChanged += (sender, ev) =>
{
recieved = true;
};
var res12 = await Tracklist.SetConsume(!res1.Result);
Assert.True(res12);
await Task.Delay(WaitMsec);
Assert.True(recieved);
recieved = false;
var res22 = await Tracklist.SetRandom(!res2.Result);
Assert.True(res22);
await Task.Delay(WaitMsec);
Assert.True(recieved);
recieved = false;
var res32 = await Tracklist.SetRepeat(!res3.Result);
Assert.True(res32);
await Task.Delay(WaitMsec);
Assert.True(recieved);
recieved = false;
var res42 = await Tracklist.SetSingle(!res4.Result);
Assert.True(res42);
await Task.Delay(WaitMsec);
Assert.True(recieved);
}
public void Clear()
{
Tracklist.Clear();
_tagSpaceManager.Clear();
}
public async Task AddTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
var tracks1 = res2.Result.First().Tracks;
Assert.True(1 <= tracks1.Length);
var uris1 = tracks1
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris1);
Assert.True(res3.Succeeded);
Assert.Equal(tracks1.Length, res3.Result.Length);
for (var i = 0; i < tracks1.Length; i++)
{
var track = tracks1[i];
var result = res3.Result[i];
Assert.Equal(track.Uri, result.Track.Uri);
}
var res4 = await Library.Search(
queryArtist : "Abba",
queryAlbum : "Waterloo"
);
Assert.True(res4.Succeeded);
Assert.True(1 <= res4.Result.Length);
var tracks2 = res4.Result.First().Tracks;
Assert.True(1 <= tracks2.Length);
var uris2 = tracks2
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res5 = await Tracklist.Add(uris2, 0);
Assert.True(res5.Succeeded);
Assert.Equal(tracks2.Length, res5.Result.Length);
for (var i = 0; i < tracks2.Length; i++)
{
var track = tracks2[i];
var result = res5.Result[i];
Assert.Equal(track.Uri, result.Track.Uri);
}
var res6 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "The Whole Thing's Started",
queryTrackName : "Do It Again"
);
Assert.True(res6.Succeeded);
Assert.True(1 <= res6.Result.Length);
var tracks3 = res6.Result.First().Tracks;
Assert.True(1 == tracks3.Length);
var insertUri = tracks3[0].Uri;
var res7 = await Tracklist.Add(insertUri, 3);
Assert.True(res7.Succeeded);
var res8 = await Tracklist.GetLength();
Assert.Equal(tracks1.Length + tracks2.Length + 1, res8.Result);
var allTracks = new List <Track>();
allTracks.AddRange(tracks2);
allTracks.AddRange(tracks1);
allTracks.Insert(3, tracks3[0]);
var res9 = await Tracklist.GetTlTracks();
Assert.True(res9.Succeeded);
Assert.Equal(allTracks.Count, res9.Result.Length);
for (var i = 0; i < allTracks.Count; i++)
{
var track = allTracks[i];
var tlTrack = res9.Result[i];
Assert.Equal(track.Uri, tlTrack.Track.Uri);
}
}
public async Task RemoveTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
var tracks1 = res2.Result.First().Tracks;
Assert.True(1 <= tracks1.Length);
var uris1 = tracks1
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris1);
Assert.True(res3.Succeeded);
var tlIds = res3.Result
.Select(e => e.TlId)
.ToArray();
var uris = res3.Result
.Select(e => e.Track.Uri)
.ToArray();
var res4 = await Tracklist.GetTlTracks();
Assert.True(res4.Succeeded);
Assert.Contains(res4.Result, e => e.TlId == tlIds[0]);
Assert.Contains(res4.Result, e => e.TlId == tlIds[1]);
Assert.Contains(res4.Result, e => e.TlId == tlIds[2]);
Assert.Contains(res4.Result, e => e.TlId == tlIds[3]);
var res5 = await Tracklist.Remove(new int[]
{
tlIds[0],
tlIds[1],
tlIds[2],
tlIds[3]
});
Assert.True(res5.Succeeded);
Assert.Equal(4, res5.Result.Length);
var res6 = await Tracklist.GetLength();
Assert.True(res6.Succeeded);
Assert.Equal(tracks1.Length - 4, res6.Result);
var res7 = await Tracklist.GetTlTracks();
Assert.True(res7.Succeeded);
Assert.DoesNotContain(res7.Result, e => e.TlId == tlIds[0]);
Assert.DoesNotContain(res7.Result, e => e.TlId == tlIds[1]);
Assert.DoesNotContain(res7.Result, e => e.TlId == tlIds[2]);
Assert.DoesNotContain(res7.Result, e => e.TlId == tlIds[3]);
Assert.Contains(res7.Result, e => e.Track.Uri == uris[4]);
Assert.Contains(res7.Result, e => e.Track.Uri == uris[5]);
Assert.Contains(res7.Result, e => e.Track.Uri == uris[6]);
var res8 = await Tracklist.Remove(new string[]
{
uris[4],
uris[5],
uris[6]
});
Assert.True(res8.Succeeded);
Assert.Equal(3, res8.Result.Length);
var res9 = await Tracklist.GetLength();
Assert.True(res9.Succeeded);
Assert.Equal(tracks1.Length - 7, res9.Result);
var res10 = await Tracklist.GetTlTracks();
Assert.True(res10.Succeeded);
Assert.DoesNotContain(res10.Result, e => e.Track.Uri == uris[4]);
Assert.DoesNotContain(res10.Result, e => e.Track.Uri == uris[5]);
Assert.DoesNotContain(res10.Result, e => e.Track.Uri == uris[6]);
Assert.Contains(res10.Result, e => e.TlId == tlIds[7]);
Assert.Contains(res10.Result, e => e.Track.Uri == uris[8]);
var res11 = await Tracklist.Remove(tlIds[7]);
Assert.True(res11.Succeeded);
#pragma warning disable xUnit2013 // Do not use equality check to check for collection size.
Assert.Equal(1, res11.Result.Length);
#pragma warning restore xUnit2013 // Do not use equality check to check for collection size.
var res12 = await Tracklist.Remove(uris[8]);
Assert.True(res12.Succeeded);
#pragma warning disable xUnit2013 // Do not use equality check to check for collection size.
Assert.Equal(1, res12.Result.Length);
#pragma warning restore xUnit2013 // Do not use equality check to check for collection size.
var res13 = await Tracklist.GetLength();
Assert.True(res13.Succeeded);
Assert.Equal(tracks1.Length - 9, res13.Result);
var res14 = await Tracklist.GetTlTracks();
Assert.True(res14.Succeeded);
Assert.DoesNotContain(res14.Result, e => e.TlId == tlIds[7]);
Assert.DoesNotContain(res14.Result, e => e.Track.Uri == uris[8]);
}
void PlayBGM(Tracklist track)
{
bgm.clip = sound [(int)track];
bgm.Play();
}
public Tracklist GetAllTracks()
{
Tracklist tracks = null;
int index = 0;
string response = GoogleMusicService(Service.streamingloadalltracks);
if (!String.IsNullOrEmpty(response))
{
tracks = new Tracklist();
tracks.lastUpdatedTimestamp = DateTime.Now;
while ((index = response.IndexOf("['slat_process']", index)) > 0)
{
index += 17;
int length = response.IndexOf("['slat_progress']", index) - index - 17;
ArrayList array = _parser.Parse(response.Substring(index, length));
foreach (ArrayList t in (array[0] as ArrayList))
{
Track track = new Track();
for (int i = 0; i < trackProperties.Length; i++)
{
string property = trackProperties[i];
if (!String.IsNullOrEmpty(property))
{
MethodInfo info = typeof(Track).GetMethod("set_" + property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (info != null && i < t.Count)
{
object ti = t[i];
if (ti != null) ti = Convert.ChangeType(ti, info.GetParameters()[0].ParameterType);
info.Invoke(track, new[] { ti });
}
else
ThrowError(String.Format("Track property '{0}' not matched!", property));
}
}
tracks.Add(track);
}
}
}
return tracks;
}
public async Task SetStateTest()
{
var res1 = await Tracklist.Clear();
Assert.True(res1);
var res2 = await Library.Search(
queryArtist : "Air Supply",
queryAlbum : "Strangers In Love"
);
Assert.True(res2.Succeeded);
Assert.True(1 <= res2.Result.Length);
Assert.True(1 <= res2.Result.First().Tracks.Length);
var uris = res2.Result.First().Tracks
.OrderBy(e => e.TrackNo)
.Select(e => e.Uri)
.ToArray();
var res3 = await Tracklist.Add(uris);
Assert.True(res3.Succeeded);
var res4 = await Playback.GetState();
Assert.True(res4.Succeeded);
if (res4.Result != PlaybackState.Stopped)
{
var res5 = await Playback.Stop();
Assert.True(res5);
}
await Task.Delay(PlaybackTest.WaitMsec);
var res6 = await Playback.Play(res3.Result[4].TlId);
Assert.True(res6);
await Task.Delay(PlaybackTest.WaitMsec);
var res7 = await Playback.SetState(PlaybackState.Paused);
Assert.True(res7);
var res8 = await Playback.GetState();
Assert.True(res8.Succeeded);
Assert.Equal(PlaybackState.Paused, res8.Result);
var res9 = await Playback.SetState(PlaybackState.Stopped);
Assert.True(res9);
var res10 = await Playback.GetState();
Assert.True(res10.Succeeded);
Assert.Equal(PlaybackState.Stopped, res10.Result);
var res11 = await Playback.SetState(PlaybackState.Playing);
Assert.True(res11);
var res12 = await Playback.GetState();
Assert.True(res12.Succeeded);
Assert.Equal(PlaybackState.Playing, res12.Result);
var res13 = await Playback.Stop();
Assert.True(res13);
}
