public void PlayTrack(Tracks track)
{
Music newTrack = null;
Console.WriteLine(track);
switch (track) {
case Tracks.GAME:
newTrack = gameMusic;
break;
case Tracks.BOSS:
newTrack = bossMusic;
break;
}
if ((newTrack == currentTrack) || (newTrack == null)) {
return;
}
if (currentTrack == null) {
newTrack.Volume = 1;
newTrack.Play();
} else {
if (currentCoroutine > -1) {
Game.Instance.Coroutine.Stop(currentCoroutine);
}
currentCoroutine = Game.Instance.Coroutine.Start(FadeTracks(currentTrack, newTrack));
}
currentTrack = newTrack;
}
public void CreateAudioSource(AudioSource source, Tracks track)
{
if ((int)track < (int)Tracks.TRACK_MAX)
{
source.clip = tracks[(int)track];
source.loop = true;
sources.Add(source);
}
}
void MoveTrack(DIRECTION direction)
{
//var selectedTracksOrdered = from selecteditem in SelectedTracks
// orderby Tracks.IndexOf(selecteditem)
// select selecteditem;
IEnumerable <TrackVM> selectedTracksOrdered;
switch (direction)
{
case DIRECTION.UP:
selectedTracksOrdered = SelectedTracks.OrderBy(i => Tracks.IndexOf(i));
foreach (TrackVM trackVM in selectedTracksOrdered)
{
int oldIndex = Tracks.IndexOf(trackVM);
if (oldIndex == 0)
{
break;
}
TracklistProvider.Instance.MoveTrack(oldIndex, oldIndex - 1);
}
break;
case DIRECTION.DOWN:
selectedTracksOrdered = SelectedTracks.OrderByDescending(i => Tracks.IndexOf(i));
int lastTrackIndex = TracklistProvider.Instance.Tracks.Count - 1;
foreach (TrackVM trackVM in selectedTracksOrdered)
{
int oldIndex = Tracks.IndexOf(trackVM);
if (oldIndex == lastTrackIndex)
{
break;
}
TracklistProvider.Instance.MoveTrack(oldIndex, oldIndex + 1);
}
break;
}
}
private async void Refresh()
{
await ServiceLocator.LocalMusicService.Clear();
if (Tracks != null)
{
Tracks.Clear();
}
if (Artists != null)
{
Artists.Clear();
}
if (Albums != null)
{
Albums.Clear();
}
if (AlbumGroups != null)
{
AlbumGroups.Clear();
}
if (SelectedArtistAlbums != null)
{
SelectedArtistAlbums.Clear();
}
var flyout = new FlyoutControl();
flyout.FlyoutContent = new MusicScanView();
await flyout.ShowAsync();
switch (SelectedTabIndex)
{
case 0:
LoadTracks();
break;
case 1:
LoadAlbums();
break;
case 2:
LoadArtists();
break;
}
}
public async Task SearchAsync(string term)
{
try
{
_tracksResponse = await _service.SearchTracksAsync(term);
Tracks = CreateIncrementalCollection(
() => _tracksResponse,
tracks => _tracksResponse = tracks,
async i => await _service.SearchTracksAsync(term, i));
foreach (var lastTrack in _tracksResponse)
{
Tracks.Add(lastTrack);
}
_albumsResponse = await _service.SearchAlbumsAsync(term);
Albums = CreateIncrementalCollection(
() => _albumsResponse,
albums => _albumsResponse = albums,
async i => await _service.SearchAlbumsAsync(term, i));
foreach (var lastAlbum in _albumsResponse)
{
Albums.Add(lastAlbum);
}
_artistsResponse = await _service.SearchArtistAsync(term);
Artists = CreateIncrementalCollection(
() => _artistsResponse,
artists => _artistsResponse = artists,
async i => await _service.SearchArtistAsync(term, i));
foreach (var lastArtist in _artistsResponse)
{
Artists.Add(lastArtist);
}
//if (_tracksResponse.TotalItems == 0)
//CurtainToast.ShowError("NoSearchResultsToast".FromLanguageResource());
}
catch (LastException ex)
{
CurtainToast.ShowError(ex.Message);
}
catch
{
CurtainToast.ShowError("NetworkIssueToast".FromLanguageResource());
}
}
public void UpdatePlaylist(ChromeDriver chromeDriver, Playlist playlist)
{
int count = 1;
foreach (var music in playlist.Music)
{
//for (int i = 0; i < 45; i++)
//{
//var music = playlist.Music[i];
string track;
if (count < 10)
{
track = BaseService.RemoveInvalidPathChars("0" + count + " " + music.Artist + " - " + music.Name + ".mp3");
}
else
{
track = BaseService.RemoveInvalidPathChars(count + " " + music.Artist + " - " + music.Name + ".mp3");
}
//Get file by number
DirectoryInfo pathDir = new DirectoryInfo(playlist.PathFolder);
FileInfo[] Tracks;
if (count < 10)
{
Tracks = pathDir.GetFiles("" + "0" + +count + "*.mp3");
}
else
{
Tracks = pathDir.GetFiles("" + +count + "*.mp3");
}
if (Tracks.Any())
{
if (Tracks.FirstOrDefault().Name != track)
{
File.Delete(playlist.PathFolder + "\\" + Tracks[0].Name);
music.NameAfterDownload = BaseService.Download(chromeDriver, playlist.PathFolder, music, count);
}
}
else
{
music.NameAfterDownload = BaseService.Download(chromeDriver, playlist.PathFolder, music, count);
}
count++;
}
BaseService.WaitToDownload(playlist.PathFolder);
BaseService.RenameFiles(playlist);
}
private List <Track> MakeTracksList(List <ListViewItem> Items)
{
var TracksList = new List <Track>();
foreach (var item in Items)
{
var Position = PlaylistView.Items.IndexOf(item);
PlaylistView.Items.Remove(item);
var track = Tracks[Position];
TracksList.Add(track);
Tracks.Remove(track);
}
return(TracksList);
}
public SoundCloudClient(IHttpClientFactory httpClientFactory, SoundCloudAuthInfo authInfo)
{
AuthInfo = authInfo;
var gateway = new SoundCloudApiGateway(httpClientFactory);
Apps = new Apps(gateway);
Comments = new Comments(gateway);
OAuth2 = new OAuth2(gateway);
Playlists = new Playlists(gateway);
Tracks = new Tracks(gateway);
Users = new Users(gateway);
Me = new Me(gateway);
Resolve = new Resolve(gateway);
}
List <Track> MakeTracksList(List <ListViewItem> Items)
{
List <Track> TracksList = new List <Track>();
foreach (ListViewItem item in Items)
{
int Position = PlaylistView.Items.IndexOf(item);
PlaylistView.Items.Remove(item);
Track track = Tracks[Position];
TracksList.Add(track);
Tracks.Remove(track);
}
return(TracksList);
}
// GET: Tracks/Add
public ActionResult Add(int?id)
{
ViewData["Listing"] = new SelectList(db.YearList, "YearListId", "YearListYear.Year");
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Tracks tracks = db.Tracks.Find(id);
if (tracks == null)
{
return(HttpNotFound());
}
return(View(tracks));
}
private Track LoadNewTrack(string filename, bool updateLength = false)
{
var track = TrackHelper.LoadTrack(filename, updateLength);
if (track == null)
{
return(null);
}
lock (Tracks)
{
Tracks.Add(track);
}
return(track);
}
private void PlayTrack(Uri path)
{
if (Tracks.Count > 0)
{
var currentTrack = Tracks.FirstOrDefault(t => t.Path == path);
if (currentTrack != null)
{
CurrentTrack = currentTrack;
CurrentUri = currentTrack.Path;
CurrentTrackName = currentTrack.FullName;
LoadedMode = MediaState.Play;
}
}
}
private string GetProjectAsJson()
{
var saveService = new PersistencyService
{
MasterTrackBpm = MasterBpm,
MasterTrackPan = MasterPan,
MasterTrackVolume = MasterVolume,
Tracks = Tracks.ToList()
};
var jsonData = saveService.CreateJsonProjectFromData();
return(jsonData);
}
private async void DeleteTrackAsync(object friendObject)
{
var track = friendObject as TrackViewModel;
var trackId = track.Id;
var action = await _page.DisplayActionSheet("Are you sure that you wanna delete Track?", "Cancel", "Delete");
if (action != "Delete")
{
return;
}
App.Database.DeleteItem(trackId);
App.SnappedPointDatabase.DeleteItemsByTrackId(trackId);
Tracks.Remove(track);
}
//TO DO: Need to generalize the parameter so it accepts a number that corresponds to the total
//number of songs the user has
//NOTE: *** Potenially may have to add a comparison function based off of individual data sizes so one user isn't favored over all others ***
public async Task GetTracks(int x)
{
//Creates list of tasks that grab (50 * i) tracks
var trackCall = Enumerable.Range(0, x).Select(i => _client.GetAsync("https://api.spotify.com/v1/me/tracks?limit=50&offset=" + (i * 50))).ToList();
var tracksGrab = await Task.WhenAll(trackCall);
foreach (var item in tracksGrab)
{
var tracksContent = await item.Content.ReadAsStringAsync();
var tracks = JsonConvert.DeserializeObject <Paging <SavedTrack> >(tracksContent);
var Swag = tracks.Items.Select(z => z.Track.Id).ToList();
Tracks.AddRange(Swag);
}
}
private void ProcessTracks()
{
if (SourceTracks != null)
{
_trackProcessor.KalmanEnabled = Filtering;
_trackProcessor.StopsDetection = StopsDetection;
_trackProcessor.SpikeDetection = SpikeDetection;
Tracks.Clear();
Tracks.AddRange(SourceTracks);
FilterResult = _trackProcessor.ProcessTracks(SourceTracks);
FilterResult.Name = "Result";
Tracks.Add(FilterResult);
}
}
public void AddTrack(File track)
{
Debug.WriteLine("Adding track: {0}", track);
var matches = Tracks.Where(x => String.Equals(x.FileName, track.FileName)).ToArray();
if (matches.Length == 0)
{
Tracks.Add(track);
NotifyPropertyChanged("Tracks");
}
else
{
Debug.WriteLine("Skipping duplicate track {0}", track);
}
}
public void AddTrack(Track track, int Position = -1)
{
var item = track.GetListViewItem(PlaylistView);
if (Position >= 0 && Position < PlaylistView.Items.Count)
{
Tracks.Insert(Position, track);
PlaylistView.Items.Insert(Position, item);
}
else
{
Tracks.Add(track);
PlaylistView.Items.Add(item);
}
}
/// <summary>
/// Gets a track from the library matching the specified filename.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>The associated track, or null if it doesn't exist</returns>
public Track GetTrackByFilename(string filename)
{
filename = filename.ToLower().Trim();
lock (Tracks)
{
var track = Tracks.FirstOrDefault(t => t.Filename.ToLower() == filename);
if (track != null && !File.Exists(track.Filename))
{
track = null;
}
return(track);
}
}
private void DeleteBtn_Click(object sender, EventArgs e)
{
var btn = (RenderBtn <Track>)sender;
Tracks.Remove(btn.Tag);
var firstName = Tracks.FirstOrDefault()?.Name;
DefaultTrackLeft.ReplaceAllValues(btn.Tag.Name, firstName);
DefaultTrackRight.ReplaceAllValues(btn.Tag.Name, firstName);
trackRemoves.Add(btn.Tag.Name);
Invalidate();
}
private async Task SearchTracks(string searchQuery)
{
if (AddTracks == true)
{
if (string.IsNullOrWhiteSpace(searchQuery))
{
await Application.Current.MainPage.DisplayAlert("Error", "Please type in the search bar", "OK");
return;
}
var searchResult = await _trackService.Get <List <Track> >(new TrackSearchRequest()
{
TrackName = searchQuery
});
Tracks.Clear();
foreach (var item in searchResult)
{
var thisTrack = await _trackService.GetById <Track>(item.TrackId);
var thisAlbum = await _albumService.GetById <Album>(thisTrack.AlbumId);
var thisArtist = await _artistService.GetById <Artist>(thisAlbum.ArtistId);
TrackHelperVM local = new TrackHelperVM()
{
TrackId = thisTrack.TrackId,
TrackName = thisTrack.TrackName,
AlbumId = thisAlbum.AlbumId,
AlbumName = thisAlbum.AlbumName,
ArtistId = thisArtist.ArtistId,
ArtistName = thisArtist.ArtistName
};
Tracks.Add(local);
}
}
else
{
Tracks.Clear();
foreach (var item in AllTracks)
{
if (item.TrackName.ToLower().Contains(searchQuery.ToLower()))
{
Tracks.Add(item);
}
}
}
}
public ModuleEditorControl CreateEditor(Module module)
{
if (!IsValidModule(module))
{
throw new ArgumentException("Invalid module");
}
var editor = new TracksEditor();
Tracks targetTracks = module as Tracks;
editor.Tracks = targetTracks;
editor.SaveCommand = new SaveEdittedModuleCommand <Tracks>(targetTracks, editor.ModifiedTracks);
return(editor);
}
private async Task LoadFromDatabase()
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Artists.Clear();
Tracks.Clear();
});
await MusicLibraryManagement.LoadFromSQL();
await DispatchHelper.InvokeAsync(() =>
{
IsMusicLibraryEmpty = !Artists.Any();
OnPropertyChanged("IsMusicLibraryEmpty");
});
}
public vmHome FindTrack(spSelectAllTitles_Result item, string userName, int listYear)
{
Tracks track = db.Tracks.Find(item.Tracks_TrackId);
var model = new vmHome()
{
ID = track.trackId,
Name = track.trackName,
TrackArtist = track.trackArtist,
TrackYear = track.trackYear,
ListYear = listYear,
VoteCount = db.spSelectAllVotes(listYear, item.Tracks_TrackId).Count(),
Voted = db.spCheckUserVote(listYear, item.Tracks_TrackId, userName).Count() != 0 ? true : false,
};
return(model);
}
public void EntityGroupWithOrderTest()
{
var result = Session.Query.All <Track>().GroupBy(t => t).OrderBy(g => g.Key.TrackId);
var resultList = result.ToList();
var expectedList = Tracks.GroupBy(t => t).OrderBy(g => g.Key.TrackId).ToList();
Assert.That(resultList, Is.Not.Empty);
Assert.AreEqual(resultList.Count, expectedList.Count());
for (var i = 0; i < resultList.Count; i++)
{
Assert.AreEqual(expectedList[i].Key, resultList[i].Key);
Assert.AreEqual(expectedList[i].Count(), resultList[i].Count());
Assert.AreEqual(expectedList[i].Count(), resultList[i].AsQueryable().Count());
}
DumpGrouping(result);
}
public override async Task <Track> LastPlayedTrack(int userId)
{
var sql = @"SELECT t.*
FROM `usertrack` ut
join `track` t on (ut.trackId = t.id)
WHERE ut.userId = {0}
ORDER by ut.lastPlayed desc
LIMIT 1";
return(await Tracks.FromSqlRaw(sql, userId)
.Include(x => x.TrackArtist)
.Include(x => x.ReleaseMedia)
.Include("ReleaseMedia.Release")
.Include("ReleaseMedia.Release.Artist")
.FirstOrDefaultAsync());
}
private void Tracks_ItemRemoved(ITrack track)
{
var musictrack =
track as MusicTrack;
NoteSelections.Remove(musictrack);
if (ActiveTrackIndex >= Tracks.Count)
{
ActiveTrackIndex = Tracks.Count - 1;
}
InvalidateTime(new Duration {
End = Tracks.MaxOrDefault(_ => _.Length.Value)
});
}
public XElement ToXML(string relativePathBase = null)
{
if (MusicSegments.Count < 1 || !MusicSegments[0].IsReadOnly)
{
throw new Exception("the default segment somehow managed to disappear from slot 0");
}
return(new XElement("timeline",
MusicFileToXML(relativePathBase),
new XElement("segments", MusicSegments.Skip(1).Select(s => s.ToXML()).ToArray()),
new XElement("default-segment", DefaultMusicSegment.GetIndex()),
new XElement("tracks", Tracks.Select(g => g.ToXML()).ToArray()),
new XElement("blocks", Blocks.Select(b => b.ToXML()).ToArray()),
new XElement("notes", Notes.Select(n => n.ToXML()).ToArray())
));
}
public bool TracksCountValid()
{
if (Tracks == null)
{
return(false);
}
var trackCount = Tracks.Count();
if (trackCount > 0 && trackCount < MaxTrackCount)
{
return(true);
}
return(false);
}
public void EntityJoinWithNullModifiedTest()
{
var id = Session.Query.All <Track>().First().TrackId;
var result = Session.Query.All <Track>()
.Select(t => (t.TrackId == id) && (t == null) ? null :
(t.TrackId == id) && (t != null) ? t.MediaType /*exception*/ :
(t.TrackId != id) && (t == null) ? null : t.MediaType)
.ToList();
var expected = Tracks
.Select(p => p.TrackId == id ? null : p)
.Select(p => p == null ? null : p.MediaType)
.ToList();
Assert.That(result, Is.Not.Empty);
Assert.AreEqual(result.Count, expected.Count);
}
public void AddTrackIfNotExisting(Uri uri)
{
var track = TrackForUri(uri);
if (track != null)
{
SelectedTrack = track;
return;
}
track = new Track {
Title = GetTitleForTrack(uri), Uri = uri
};
Tracks.Add(track);
SelectedTrack = track;
}
public virtual void Remove(T track)
{
var removingPlayingTrack = CurrentTrack == track;
Tracks.Remove(track);
if (CurrentTrackIndex >= Tracks.Count)
{
CurrentTrackIndex = Tracks.Count - 1;
}
if (removingPlayingTrack)
{
OnTrackChanged(CurrentTrack);
}
}
AudioSource GetInSyncAudioSource(Tracks track)
{
foreach (AudioSource source in sources)
{
if (source.clip == tracks[(int)track] && !offsetSources.Contains(source)) return source;
}
return null;
}
public static Tracks UpsertTrack(Tracks tracks)
{
var conn = new SqlConnection(Config.ChinookConnection);
conn.Open();
var cmd = new SqlCommand("UpsertTrack", conn)
{
CommandType = CommandType.StoredProcedure
};
// Return value as parameter
SqlParameter returnValue = new SqlParameter("returnVal", SqlDbType.Int);
returnValue.Direction = ParameterDirection.ReturnValue;
cmd.Parameters.Add(returnValue);
cmd.Parameters.AddWithValue("@AlbumId", tracks.AlbumId);
cmd.Parameters.AddWithValue("@Bytes", tracks.Bytes);
cmd.Parameters.AddWithValue("@Composer", tracks.Composer);
cmd.Parameters.AddWithValue("@GenreId", tracks.GenreId);
cmd.Parameters.AddWithValue("@MediaTypeId", tracks.MediaTypeId);
cmd.Parameters.AddWithValue("@Milliseconds", tracks.Milliseconds);
cmd.Parameters.AddWithValue("@Name", tracks.Name);
cmd.Parameters.AddWithValue("@TrackId", tracks.TrackId);
cmd.Parameters.AddWithValue("@UnitPrice", tracks.UnitPrice);
cmd.ExecuteNonQuery();
int id = Convert.ToInt32(returnValue.Value);
tracks.TrackId = id;
conn.Close();
return tracks;
}
public int NumActiveSources(Tracks track)
{
int num = 0;
for (int i = 0; i < sources.Count; ++i)
{
if (sources[i].clip == tracks[(int)track]) ++num;
}
return num;
}
