private void LstArtistes_SelectedIndexChanged(object sender, EventArgs e)
{
this.lstAlbums.SelectedIndexChanged -= new System.EventHandler(this.LstAlbums_SelectedIndexChanged);
selectedArtist = (Artist)lstArtistes.SelectedItem;
lblArtisteNom.Text = selectedArtist.name;
picArtiste.ImageLocation = selectedArtist.picture;
lklDeezerLien.Text = selectedArtist.link;
grbArtisteInfos.Visible = true;
selectedArtistDetail = DeezerApi.getDetailsArtistById(selectedArtist.id);
btnEcouterExtraits.Enabled = true;
if (selectedArtistDetail.nbAlbums == 0)
{
//MessageBox.Show("Désolé, les extrait pour '" + selectedArtist.name + "' ne sont pas disponibles...", "Zik'nCo : Avertissement ",MessageBoxButtons.OK, MessageBoxIcon.Warning);
lblMessage.Text = "Désolé, les extrait pour '" + selectedArtist.name + "' ne sont pas disponibles...";
erp.SetError(btnEcouterExtraits, "Aucun extrait pour cette artiste");
}
else
{
lblMessage.Text = "";
List <Album> lesAlbums = selectedArtistDetail.getLesAlbums();
lstAlbums.DataSource = lesAlbums;
lstAlbums.DisplayMember = "title";
this.lstAlbums.SelectedIndexChanged += new System.EventHandler(this.LstAlbums_SelectedIndexChanged);
LstAlbums_SelectedIndexChanged(this, new EventArgs());
}
}
protected override void SetMediaPosition(double pos)
{
Logger.LogTrace("DeezerRenderer::SetMediaPosition pos={0}", pos);
if (FilterState != FilterState.Stopped)
{
if (_dzPlayer != IntPtr.Zero)
{
dz_error_t err;
int resumePos = (int)pos;
if (resumePos != RenderPosition)
{
err = DeezerApi.dz_player_seek(_dzPlayer, null, IntPtr.Zero, (UInt64)(resumePos * 1e6));
DeezerApi.HandleDzErrorCode("dz_player_seek", err);
}
if (_evtPlayerPaused.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("[Event toggled by dz_player_seek]", dz_error_t.DZ_ERROR_PLAYER_SEEK_TIMEOUT);
}
Logger.LogTrace("[Event toggled by dz_player_seek] => DZ_PLAYER_EVENT_RENDER_TRACK_PAUSED");
}
}
}
private void rechercherAlbum()
{
List <Album> lesAlbums = new List <Album>();
String albumRecherche = txtBoxRecherche.Text;
lesAlbums = DeezerApi.getAllAlbumsByName(albumRecherche);
lblMessage.Text = string.Empty;
if (lesAlbums.Count == 0)
{
lblMessage.Text = "Désolé, l'album " + albumRecherche + " n'est pas sur Deezer";
erp.SetError(txtBoxRecherche, "Album inconnu");
}
else
{
this.lstBoxAlbum.SelectedIndexChanged -= new System.EventHandler(this.LstBoxAlbum_SelectedIndexChanged);
lstBoxAlbum.DataSource = lesAlbums;
lstBoxAlbum.DisplayMember = "title";
this.lstBoxAlbum.SelectedIndexChanged += new System.EventHandler(this.LstBoxAlbum_SelectedIndexChanged);
erp.SetError(txtBoxRecherche, string.Empty);
LstBoxAlbum_SelectedIndexChanged(this, new EventArgs());
}
}
private void rechercherArtistes()
{
List <Artist> lesArtistes = new List <Artist>();
String artisteRecherche = txtArtisteRecherche.Text;
lesArtistes = DeezerApi.getAllArtistsByName(artisteRecherche);
lblMessage.Text = string.Empty;
if (lesArtistes.Count == 0)
{
//.MessageBox.Show("Désolé, l'artiste " + artisteRecherche + "n'est pas sur Deezer", "Zik'nCo : Avertissement", MessageBoxButtons.OK, MessageBoxIcon.Warning);
lblMessage.Text = "Désolé, l'artiste " + artisteRecherche + "n'est pas sur Deezer";
erp.SetError(txtArtisteRecherche, "Artiste inconnu");
}
else
{
lstArtistes.DataSource = lesArtistes;
lstArtistes.DisplayMember = "name";
erp.SetError(txtArtisteRecherche, string.Empty);
grbArtisteInfos.Visible = true;
}
}
private void bntRechercher_Click(object sender, EventArgs e)
{
//Artist monArtist = new Artist();
//déclaration et instanciation de la collection (liste) d'artistes
List <Artist> lesArtistes = new List <Artist>();
//string recherche = "zaz";
string recherche = txtArtisteRecherche.Text;
//monArtist = DeezerApi.getFirstArtistByName(recherche);
//affection de la collection
lesArtistes = DeezerApi.getAllArtistsByName(recherche);
//if (monArtist == null)
if (lesArtistes.Count == 0)
{
// Console.WriteLine("\n Désolé, l'artiste " + recherche + " est inconnu sur Deezer. Vérifiez l'orthographe");
MessageBox.Show("\n Désolé, l'artiste '" + recherche + "' est inconnu sur Deezer. Vérifiez l'orthographe", "Zick'nCo : Avertissement", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
//alimentation de la liste lstArtistes par la collection lesArtistes dans le DataSource.
lstArtistes.DataSource = lesArtistes;
lstArtistes.DisplayMember = "name";
}
}
private void btnEcouterExtraits_Click(object sender, EventArgs e)
{
Artist selectedArtistDetails = new Artist();
selectedArtistDetails = DeezerApi.getDetailsArtistById(selectedArtist.id);
if (selectedArtistDetails.nbAlbums == 0)
{
MessageBox.Show("Désolé, les extraits pour '" + selectedArtist.name + "' ne sont pas disponibles...", "Zik'nCo : Avertissement", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
FrmLecteurMultimedia formulaire = new FrmLecteurMultimedia();
List <Album> lesAlbums = selectedArtistDetails.getLesAlbums();
foreach (Album unAlbum in lesAlbums)
{
List <Track> lesTracks = unAlbum.getLesTracks();
foreach (Track unTrack in lesTracks)
{
//On lit chaque titre de chaque Album de l'artiste
WMPLib.IWMPMedia unMedia = formulaire.wmpLecteur.newMedia(unTrack.preview);
formulaire.wmpLecteur.currentPlaylist.appendItem(unMedia);
}
}
formulaire.Show();
formulaire.wmpLecteur.Ctlcontrols.play();
}
}
//private void ResetAllEvents()
//{
// _evtAppUserOfflineAvailable.Reset();
// _evtAppUserLoginOK.Reset();
// _evtPlayerPaused.Reset();
// _evtPlayerStreamReadyAfterSeek.Reset();
// _evtQueueListLoaded.Reset();
// _evtPlayerPlaybackStarted.Reset();
//}
protected override void DoStopRenderer()
{
StackTrace st = new StackTrace();
Logger.LogTrace("DeezerRenderer::DoStopRenderer call Stack = {0}", st.ToString());
if (FilterState != FilterState.Stopped)
{
if (_dzPlayer != IntPtr.Zero)
{
dz_error_t err;
_evtPlayerPlaybackStopped.Reset();
err = DeezerApi.dz_player_stop(_dzPlayer, null, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_player_stop", err);
if (_evtPlayerPlaybackStopped.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("dz_player_pause", dz_error_t.DZ_ERROR_PLAYER_STOP_TIMEOUT);
}
RenderPosition = 0;
Logger.LogTrace("dz_player_stop => Success");
}
}
}
private void frmCoverFlow_Load(object sender, EventArgs e)
{
selectedArtistDetails = DeezerApi.getDetailsArtistById("71069");
lesAlbums = selectedArtistDetails.getLesAlbums();
// On utilise un WebClient pour télécharger les images des pochettes d'album
// (le cover flow ne peut afficher que des images locales)
WebClient wClient = new WebClient();
string nomImage;
int i;
for (i = 0; i < lesAlbums.Count; i++)
{
nomImage = "image" + i + ".jpg";
//Téléchargement de l'image de l'artiste pour affichage dans le cover flow
wClient.DownloadFile(lesAlbums[i].cover, nomImage);
//Création de la vignette d'album (pochette). Premier paramètre : titre (title)
Card c = new Card(lesAlbums[i].title, nomImage);
//Ajout au cover flow
iC3DAlbums.IndexCards.Add(c);
}
iC3DAlbums.IndexCards.LoadTexturesToMemory();
// Lorsque le cover flow est affiché, on charge les titres du premier album
chargerTitresSelectedAlbum();
// wmpLecteur.CurrentItemChange -= new EventHandler(wmpLecteur_CurrentItemChange);
}
protected override void DoStartRendererWithHint(RenderingStartHint startHint)
{
dz_error_t err;
_needNaturalNext = false;
Logger.LogTrace("DeezerRenderer::DoStartRendererWithHint startHint={0}", startHint);
if (renderMediaName == null || renderMediaName.Length <= 0)
{
return;
}
CheckIfInitialized();
if (_dzConnect == IntPtr.Zero || _dzPlayer == IntPtr.Zero)
{
DeezerApi.HandleDzErrorCode("DeezerRenderer::DoStartRendererWithHint", dz_error_t.DZ_ERROR_CLASS_INSTANTIATION);
}
// --------------------------------------------------------------------
_evtQueueListLoaded.Reset();
err = DeezerApi.dz_player_load(_dzPlayer, null, IntPtr.Zero, renderMediaName);
DeezerApi.HandleDzErrorCode("dz_player_load", err);
if (_evtQueueListLoaded.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("dz_player_load", dz_error_t.DZ_ERROR_PLAYER_LOAD_TIMEOUT);
}
Logger.LogTrace("dz_player_load => Success");
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// Start playback using dz_player_play
// This will trigger DZ_PLAYER_EVENT_RENDER_TRACK_START
// Upon completion, _evtPlayerPlaybackStarted will be set.
_evtPlayerPlaybackStarted.Reset();
err = DeezerApi.dz_player_play(_dzPlayer, null, IntPtr.Zero,
dz_player_play_command_t.DZ_PLAYER_PLAY_CMD_START_TRACKLIST,
DeezerInterop.PlayerApi.Constants.DZ_INDEX_IN_QUEUELIST_CURRENT);
DeezerApi.HandleDzErrorCode("dz_player_play", err);
if (_evtPlayerPlaybackStarted.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("dz_player_play", dz_error_t.DZ_ERROR_PLAYER_PLAY_TIMEOUT);
}
Logger.LogTrace("dz_player_play => Success");
// --------------------------------------------------------------------
}
protected override void SetAudioVolume(int vol)
{
if (_dzPlayer != IntPtr.Zero)
{
dz_error_t err;
Logger.LogTrace("DeezerRenderer::SetAudioVolume vol={0}", vol);
err = DeezerApi.dz_player_set_output_volume(_dzPlayer, null, IntPtr.Zero, vol);
DeezerApi.HandleDzErrorCode("dz_player_set_output_volume", err);
}
}
private void OnApplicationConnectEvent(IntPtr handle, IntPtr evtHandle, IntPtr userData)
{
dz_connect_event_t evtType = DeezerApi.dz_connect_event_get_type(evtHandle);
Logger.LogTrace("DeezerRenderer::OnApplicationConnectEvent evtType={0}", evtType);
switch (evtType)
{
case dz_connect_event_t.DZ_CONNECT_EVENT_USER_OFFLINE_AVAILABLE:
_evtAppUserOfflineAvailable.Set();
break;
case dz_connect_event_t.DZ_CONNECT_EVENT_USER_LOGIN_OK:
_evtAppUserLoginOK.Set();
break;
}
}
private void btnRecherche_Click(object sender, EventArgs e)
{
recherche = txtAlbumRecherche.Text;
lesAlbums = DeezerApi.getAllAlbumsByName(recherche);
if (txtAlbumRecherche.Text == string.Empty)
{
erp.SetError(txtAlbumRecherche, MESSAGE_SAISIE_ALBUM);
lblMessage.Text = MESSAGE_SAISIE_ALBUM;
}
else
{
Cursor.Current = Cursors.WaitCursor;
lblMessage.Text = MESSAGE_RECHERCHE_ALBUM;
lblMessage.Refresh();
rechercherArtistes();
}
}
private void lstAlbum_SelectedIndexChanged(object sender, EventArgs e)
{
selectedAlbum = (Album)lstAlbum.SelectedItem;
selectedAlbum = DeezerApi.getDetailsAlbumById(selectedAlbum.id);
lstTitresAlbum.DataSource = selectedAlbum.getLesTracks();
lstTitresAlbum.DisplayMember = "title";
lstTitresAlbum.SelectedIndexChanged += new System.EventHandler(this.lstTitresAlbum_SelectedIndexChanged);
lstTitresAlbum_SelectedIndexChanged(this, new EventArgs());
lblArtistName.Text = selectedAlbum.theArtist.name;
picCoverAlbum.ImageLocation = selectedAlbum.cover;
picArtist.ImageLocation = selectedAlbum.theArtist.picture;
}
private void CleanupAppContext()
{
Logger.LogTrace("DeezerRenderer::CleanupAppContext => Cleaning up app context ...");
dz_error_t err;
if (_dzPlayer != IntPtr.Zero)
{
//_evtPlayerDeactivated.Reset();
//_dzPlayerDeactivatedCB = new dz_activity_operation_callback(OnPlayerDeactivated);
err = DeezerApi.dz_player_deactivate(_dzPlayer, _dzPlayerDeactivatedCB, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_player_deactivate", err, false);
//_evtPlayerDeactivated.WaitOne(DZ_OPERATION_TIMEOUT);
Thread.Sleep(2000);
Logger.LogTrace("dz_player_deactivate => Assuming Success");
DeezerApi.dz_object_release(_dzPlayer);
_dzPlayer = IntPtr.Zero;
}
if (_dzConnect != IntPtr.Zero)
{
//_evtConnectDeactivated.Reset();
//_dzConnectDeactivatedCB = new dz_activity_operation_callback(OnConnectDeactivated);
err = DeezerApi.dz_connect_deactivate(_dzConnect, _dzConnectDeactivatedCB, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_connect_deactivate", err, false);
//_evtConnectDeactivated.WaitOne(DZ_OPERATION_TIMEOUT);
Thread.Sleep(2000);
Logger.LogTrace("dz_connect_deactivate => Assuming Success");
DeezerApi.dz_object_release(_dzConnect);
_dzConnect = IntPtr.Zero;
}
}
private void BtnEcouterExtrait_Click(object sender, EventArgs e)
{
FrmLecteurMultemedia formulaire = new FrmLecteurMultemedia();
selectedAlbum = (Album)lstBoxAlbum.SelectedItem;
selectedAlbumDetail = DeezerApi.getDetailsAlbumById(selectedAlbum.id);
List <Track> lesTracks = selectedAlbumDetail.getLesTracks();
foreach (Track unTrack in lesTracks)
{
WMPLib.IWMPMedia unMedia = formulaire.wmpLecteur.newMedia(unTrack.preview);
formulaire.wmpLecteur.currentPlaylist.appendItem(unMedia);
}
formulaire.Show();
formulaire.wmpLecteur.Ctlcontrols.play();
}
protected override void DoResumeRenderer(double fromPosition)
{
Logger.LogTrace("DeezerRenderer::DoResumeRenderer fromPosition={0}", fromPosition);
dz_error_t err;
if (_evtPlayerPaused.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("DeezerRenderer::DoResumeRenderer", dz_error_t.DZ_ERROR_PLAYER_PAUSE_NOT_STARTED);
}
Logger.LogTrace("DeezerRenderer::DoResumeRenderer player is now paused.");
if (FilterState == FilterState.Paused)
{
if (_dzPlayer != IntPtr.Zero)
{
int resumePos = (int)fromPosition;
if (resumePos != RenderPosition)
{
// dz_player_seek will trigger DZ_PLAYER_EVENT_MEDIASTREAM_DATA_READY_AFTER_SEEK
// Upon completion, _evtPlayerStreamReadyAfterSeek will be set.
_evtPlayerStreamReadyAfterSeek.Reset();
err = DeezerApi.dz_player_seek(_dzPlayer, null, IntPtr.Zero, (UInt64)(resumePos * 1e6));
DeezerApi.HandleDzErrorCode("dz_player_seek", err);
if (_evtPlayerStreamReadyAfterSeek.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("dz_player_seek", dz_error_t.DZ_ERROR_PLAYER_SEEK_TIMEOUT);
}
Logger.LogTrace("dz_player_seek => DZ_PLAYER_EVENT_MEDIASTREAM_DATA_READY_AFTER_SEEK");
}
err = DeezerApi.dz_player_resume(_dzPlayer, null, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_player_resume", err);
}
}
}
private void LstBoxAlbum_SelectedIndexChanged(object sender, EventArgs e)
{
List <Album> lesAlbums = new List <Album>();
selectedAlbum = (Album)lstBoxAlbum.SelectedItem;
selectedAlbumDetail = DeezerApi.getDetailsAlbumById(selectedAlbum.id);
lblNomAlbum.Text = selectedAlbum.title;
lblNomArtiste.Text = selectedAlbum.theArtist.name;
picAlbum.ImageLocation = selectedAlbum.cover;
picArtiste.ImageLocation = selectedAlbum.theArtist.picture;
linkAlbum.Text = selectedAlbumDetail.link;
btnEcouterExtrait.Enabled = true;
lblMessage.Text = "";
List <Track> lesTracks = selectedAlbumDetail.getLesTracks();
lstBoxTitre.DataSource = lesTracks;
lstBoxTitre.DisplayMember = "title";
}
private void FrmPlaylist_Load(object sender, EventArgs e)
{
Artist theArtist = DeezerApi.getFirstArtistByName("STROMAE");
List <Album> lesAlbums = DeezerApi.getAllAlbumsByArtist(theArtist);
Album premierAlbum = lesAlbums[0];
premierAlbum = DeezerApi.getDetailsAlbumById(premierAlbum.id);
List <Track> lesTracks = premierAlbum.getLesTracks();
int i = 0;
while (i < lesTracks.Count)
{
Track unTrack = lesTracks[i];
lstGauche.Items.Add(unTrack);
lstGauche.DisplayMember = "name";
i++;
}
lstGauche.SelectedIndex = 0;
btnVersGaucheUn.Enabled = false;
btnVersGaucheTous.Enabled = false;
btnJouerExtraits.Enabled = false;
}
protected override void DoPauseRenderer()
{
Logger.LogTrace("DeezerRenderer::DoPauseRenderer");
if (FilterState == FilterState.Running)
{
if (_dzPlayer != IntPtr.Zero)
{
dz_error_t err;
_evtPlayerPaused.Reset();
err = DeezerApi.dz_player_pause(_dzPlayer, null, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_player_pause", err);
if (_evtPlayerPaused.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("dz_player_pause", dz_error_t.DZ_ERROR_PLAYER_PAUSE_TIMEOUT);
}
Logger.LogTrace("dz_player_pause => Success");
}
}
}
private void SetupAppContext()
{
if (_connected == false)
{
_evtAppUserOfflineAvailable.Reset();
_evtAppUserLoginOK.Reset();
Logger.LogTrace("DeezerRenderer::SetupConfig => Creating app context ...");
dz_error_t err;
_dzRenderProgressCB = new dz_player_onrenderprogress_cb(OnRenderProgress);
_dzPlayerEventCB = new dz_player_onevent_cb(OnPlayerEvent);
_dzRendererEventCB = new dz_player_onrendererevent_cb(OnRendererEvent);
_dzConnect = DeezerApi.dz_connect_new(_dzConfig);
if (_dzConnect == IntPtr.Zero)
{
DeezerApi.HandleDzErrorCode("dz_connect_new", dz_error_t.DZ_ERROR_CLASS_INSTANTIATION);
}
//err = DeezerApi.dz_connect_debug_log_disable(_dzConnect);
//DeezerApi.HandleDzErrorCode("dz_connect_debug_log_disable", err);
err = DeezerApi.dz_connect_activate(_dzConnect, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_connect_activate", err);
err = DeezerApi.dz_connect_cache_path_set(_dzConnect, null, IntPtr.Zero, USER_CACHE_PATH);
DeezerApi.HandleDzErrorCode("dz_connect_cache_path_set", err);
_dzPlayer = DeezerApi.dz_player_new(_dzConnect);
if (_dzPlayer == IntPtr.Zero)
{
DeezerApi.HandleDzErrorCode("dz_player_new", dz_error_t.DZ_ERROR_CLASS_INSTANTIATION);
}
err = DeezerApi.dz_player_activate(_dzPlayer, IntPtr.Zero);
DeezerApi.HandleDzErrorCode("dz_player_activate", err);
err = DeezerApi.dz_player_set_event_cb(_dzPlayer, _dzPlayerEventCB);
DeezerApi.HandleDzErrorCode("dz_player_set_event_cb", err);
err = DeezerApi.dz_player_set_render_progress_cb(_dzPlayer, _dzRenderProgressCB, (UInt64)5e5);
DeezerApi.HandleDzErrorCode("dz_player_set_render_progress_cb", err);
err = DeezerApi.dz_player_set_renderer_event_cb(_dzPlayer, _dzRendererEventCB);
DeezerApi.HandleDzErrorCode("dz_player_set_renderer_event_cb", err);
string token = ProTONEConfig.DeezerUserAccessToken;
err = DeezerApi.dz_connect_set_access_token(_dzConnect, null, IntPtr.Zero, token);
DeezerApi.HandleDzErrorCode("dz_connect_set_access_token", err);
err = DeezerApi.dz_connect_offline_mode(_dzConnect, null, IntPtr.Zero, false);
DeezerApi.HandleDzErrorCode("dz_connect_offline_mode", err);
if (_evtAppUserLoginOK.WaitOne(DZ_OPERATION_TIMEOUT) == false)
{
DeezerApi.HandleDzErrorCode("DeezerRenderer::SetupConfig", dz_error_t.DZ_ERROR_CONNECT_SESSION_LOGIN_FAILED);
}
_connected = true;
}
}
private void OnRendererEvent(IntPtr handle, IntPtr evtHandle, IntPtr userdata)
{
string s = DeezerApi.dz_renderer_event_get_infos(evtHandle);
Logger.LogTrace("DeezerRenderer::OnRendererEvent info={0}", s ?? "<null>");
}
private void OnPlayerEvent(IntPtr handle, IntPtr evtHandle, IntPtr userdata)
{
dz_player_event_t evtType = DeezerApi.dz_player_event_get_type(evtHandle);
Logger.LogTrace("DeezerRenderer::OnPlayerEvent evtType={0}", evtType);
switch (evtType)
{
case dz_player_event_t.DZ_PLAYER_EVENT_QUEUELIST_TRACK_SELECTED:
{
string selectedInfo = DeezerApi.dz_player_event_track_selected_dzapiinfo(evtHandle);
dynamic obj2 = JObject.Parse(selectedInfo);
_duration = obj2.duration;
}
break;
case dz_player_event_t.DZ_PLAYER_EVENT_RENDER_TRACK_START:
_evtPlayerPlaybackStarted.Set();
FilterState = FilterState.Running;
break;
case dz_player_event_t.DZ_PLAYER_EVENT_RENDER_TRACK_RESUMED:
FilterState = FilterState.Running;
break;
case dz_player_event_t.DZ_PLAYER_EVENT_RENDER_TRACK_PAUSED:
_evtPlayerPaused.Set();
FilterState = FilterState.Paused;
break;
case dz_player_event_t.DZ_PLAYER_EVENT_RENDER_TRACK_END:
case dz_player_event_t.DZ_PLAYER_EVENT_RENDER_TRACK_REMOVED:
if (_needNaturalNext)
{
// HACK: The Deezer Native SDK told us that we should advance
// to the next item by using a "natural next" (WTF is that anyways ??)
_needNaturalNext = false;
// So this is exactly what we'll give it ...
OPMShortcutEventArgs args = new OPMShortcutEventArgs(OPMShortcut.CmdNext);
EventDispatch.DispatchEvent(EventNames.ExecuteShortcut, args);
}
else
{
_evtPlayerPlaybackStopped.Set();
FilterState = FilterState.Stopped;
RenderPosition = 0;
}
break;
case dz_player_event_t.DZ_PLAYER_EVENT_MEDIASTREAM_DATA_READY_AFTER_SEEK:
_evtPlayerStreamReadyAfterSeek.Set();
break;
case dz_player_event_t.DZ_PLAYER_EVENT_QUEUELIST_NEED_NATURAL_NEXT:
_needNaturalNext = true;
break;
case dz_player_event_t.DZ_PLAYER_EVENT_QUEUELIST_LOADED:
_evtQueueListLoaded.Set();
break;
case dz_player_event_t.DZ_PLAYER_EVENT_QUEUELIST_NO_RIGHT:
_evtQueueListLoaded.Reset();
break;
}
}
