public void ReproducirCancion(Cancion c) //reproduce una cancion por path o por sus metadatos
{
timerCancion.Enabled = false;
timerMetadatos.Enabled = false;
estadoReproductor = EstadoReproductor.Detenido;
try
{
SetPATH(c);
}
catch (DirectoryNotFoundException)
{
Log.ImprimirMensaje("No se encuentra el directorio", TipoMensaje.Error);
return;
}
CancionLocalReproduciendo = c;
if (string.IsNullOrEmpty(c.PATH))
{
MessageBox.Show(c.titulo + " " + c.album.nombre + Environment.NewLine + Programa.textosLocal.GetString("error_cancion"));
Log.ImprimirMensaje("No se encuentra la canción", TipoMensaje.Error);
return;
}
else
{
nucleo.Apagar();
}
try
{
nucleo.CargarCancion(CancionLocalReproduciendo.PATH);
nucleo.Reproducir();
}
catch (Exception)
{
MessageBox.Show(Programa.textosLocal.GetString("errorReproduccion"));
Log.ImprimirMensaje("Error en la reproducción", TipoMensaje.Error);
return;
}
if (GuardarHistorial)
{
using (StreamWriter escritor = new StreamWriter(Historial.FullName, true))
{
escritor.WriteLine(NumCancion + " - " + c.album.artista + " - " + c.titulo);
NumCancion++;
}
}
PrepararReproductor();
if (c.album.caratula != null)
{
if (c.album.caratula != "")
{
pictureBoxCaratula.Image = System.Drawing.Image.FromFile(c.album.caratula);
}
else
{
pictureBoxCaratula.Image = System.Drawing.Image.FromFile(c.album.DirectorioSonido + "\\folder.jpg");
}
}
timerCancion.Enabled = true;
timerMetadatos.Enabled = true;
buttonTwit.Enabled = true;
}
private void ApagarSpotify()
{
backgroundWorker.CancelAsync();
_spotify.PausePlayback();
buttoncrearLR.Show();
buttonSpotify.Text = Programa.textosLocal.GetString("cambiarSpotify");
timerSpotify.Enabled = false;
estadoReproductor = EstadoReproductor.Detenido;
Spotify = false;
timerCancion.Enabled = false;
timerMetadatos.Enabled = false;
pictureBoxCaratula.Image = Properties.Resources.albumdesconocido;
button2.Enabled = true;
trackBarPosicion.Value = 0;
dur = new TimeSpan(0);
pos = new TimeSpan(0);
labelDuracion.Text = "-";
labelPosicion.Text = "0:00";
Volumen = 1.0f;
Text = Programa.textosLocal.GetString("reproductor");
toolStripStatusLabelCorreoUsuario.Text = "";
labelDatosCancion.Text = "";
Icon = Properties.Resources.iconoReproductor;
checkBoxFoobar.Visible = true;
buttonAgregar.Hide();
}
/// <summary>
/// Limpia el reproductor
/// </summary>
public void LimpiarReproductor()
{
DetenerRecepcionDeCancion();
_waveOutEvent.Stop();
_estadoReproductor = EstadoReproductor.Detenido;
_colaDeReproduccion.LimpiarCola();
}
/// <summary>
/// Se encarga de comenzar a reproducir una cancion desde un archivo local
/// </summary>
/// <param name="ruta">La ruta de la cancion a reproducir</param>
private void ReproducirCancionSinConexion(string ruta)
{
try
{
DetenerRecepcionDeCancion();
_waveOutEvent.Stop();
_bufferCancion = new MemoryStream(File.ReadAllBytes(ruta));
_mp3Reader = new Mp3FileReader(_bufferCancion);
_blockAlignedStream = new WaveChannel32(_mp3Reader);
_waveOutEvent = new WaveOut(WaveCallbackInfo.FunctionCallback());
_waveOutEvent.Init(_blockAlignedStream);
_estadoReproductor = EstadoReproductor.Reproduciendo;
_seguidorDeEventosDelReproductor.Start();
_waveOutEvent.Play();
}
catch (Exception ex)
{
new MensajeEmergente().MostrarMensajeError(ex.Message);
_waveOutEvent.Stop();
OnCambioEstadoReproduccion?.Invoke(false);
_seguidorDeEventosDelReproductor.Stop();
_estadoReproductor = EstadoReproductor.Detenido;
if (_bufferCancion != null && _blockAlignedStream != null)
{
_bufferCancion.Dispose();
_blockAlignedStream.Dispose();
}
}
}
/// <summary>
/// Reproduce la cancion anterior de la cola o reinicia la reproduccion de la actual si el tiempo de reproduccion
/// es menor o igual a 10 segundos
/// </summary>
public void ReproducirCancionAnterior()
{
try
{
if (_blockAlignedStream.CurrentTime.TotalSeconds <= 10)
{
switch (_colaDeReproduccion.ObtenerTipoDeCancionAnterior())
{
case Cola.TipoCancionAReproducir.Cancion:
var cancionAnterior = _colaDeReproduccion.ObtenerCancion(true);
if (cancionAnterior != null)
{
EmpezarAReproducirCancion(cancionAnterior);
}
break;
case Cola.TipoCancionAReproducir.CancionPersonal:
var cancionPersonalAnterior = _colaDeReproduccion.ObtenerCancionPersonal(true);
if (cancionPersonalAnterior != null)
{
EmpezarAReproducirCancionPersonal(cancionPersonalAnterior);
}
break;
case Cola.TipoCancionAReproducir.CancionSinConexion:
var cancionSinConexionAnteriror = _colaDeReproduccion.ObtenerCancionSinConexion(true);
if (cancionSinConexionAnteriror != null)
{
EmpezarAReproducirCancionSinConexion(cancionSinConexionAnteriror);
}
break;
}
}
else
{
if (_blockAlignedStream != null)
{
_blockAlignedStream.Seek(0, SeekOrigin.Begin);
OnAvanceCancion?.Invoke(0);
if (_estadoReproductor == EstadoReproductor.Detenido)
{
_waveOutEvent.Play();
if (_estadoReproductor == EstadoReproductor.Detenido ||
_estadoReproductor == EstadoReproductor.Pausado)
{
_seguidorDeEventosDelReproductor.Start();
_estadoReproductor = EstadoReproductor.Reproduciendo;
}
OnCambioEstadoReproduccion?.Invoke(true);
}
}
}
}
catch (NullReferenceException)
{
}
}
/// <summary>
/// Empieza la reproduccion de una cancion sin conexion sin afectar a la cola de reproduccion
/// </summary>
/// <param name="cancion">La cancion sin conexion a reproducir</param>
public void EmpezarAReproducirCancionSinConexion(CancionSinConexion cancion)
{
OnActualizacionCola?.Invoke(_colaDeReproduccion.ObtenerProximosElementosEnCola());
OnIniciaReproduccionCancion?.Invoke(cancion);
OnCambioEstadoReproduccion?.Invoke(true);
_estadoReproductor = EstadoReproductor.Reproduciendo;
_duracionTotalDeCancionEnReproduccion = cancion.duracion;
ReproducirCancionSinConexion(cancion.ruta_cancion);
}
/// <summary>
/// Empieza la reproduccion de una cancion personal sin afectar la cola de reproduccion
/// </summary>
/// <param name="cancionPersonal">La cancion personal a reproducir</param>
public void EmpezarAReproducirCancionPersonal(CancionPersonal cancionPersonal)
{
OnActualizacionCola?.Invoke(_colaDeReproduccion.ObtenerProximosElementosEnCola());
OnIniciaReproduccionCancionPersonal?.Invoke(cancionPersonal);
OnCambioEstadoReproduccion?.Invoke(true);
_estadoReproductor = EstadoReproductor.Reproduciendo;
_duracionTotalDeCancionEnReproduccion = cancionPersonal.duracion;
ReproducirCancion(cancionPersonal.id, true);
}
private void ReproducirCancion(string path)
{
timerCancion.Enabled = false;
timerMetadatos.Enabled = false;
estadoReproductor = EstadoReproductor.Detenido;
nucleo.Apagar();
try
{
nucleo.CargarCancion(path);
nucleo.Reproducir();
}
catch (Exception)
{
MessageBox.Show(Programa.textosLocal.GetString("errorReproduccion"));
Log.ImprimirMensaje("Error en la reproducción", TipoMensaje.Error);
return;
}
Log.ImprimirMensaje("Reproduciendo " + path, TipoMensaje.Correcto);
PrepararReproductor();
try
{
System.Drawing.Image caratula = nucleo.GetCaratula();
if (caratula != null)
{
pictureBoxCaratula.Image = caratula;
}
else
{
FileInfo fi = new FileInfo(openFileDialog1.FileName);
DirectoryInfo info = new DirectoryInfo(fi.DirectoryName);
foreach (FileInfo item in info.GetFiles())
{
if (item.Name == "cover.jpg" || item.Name == "folder.jpg")
{
pictureBoxCaratula.Image = System.Drawing.Image.FromFile(item.FullName);
}
else
{
pictureBoxCaratula.Image = Properties.Resources.albumdesconocido;
}
}
}
}
catch (NullReferenceException)
{
Log.ImprimirMensaje("No hay carátula, usando por defecto", TipoMensaje.Advertencia);
pictureBoxCaratula.Image = Properties.Resources.albumdesconocido;
}
timerCancion.Enabled = true;
timerMetadatos.Enabled = true;
buttonTwit.Enabled = true;
}
private String GetTextoReproductor(EstadoReproductor er)
{
switch (er)
{
case EstadoReproductor.Reproduciendo:
return("❚❚");
case EstadoReproductor.Pausado:
case EstadoReproductor.Detenido:
return("▶");
}
return("");
}
private void PrepararReproductor()
{
nucleo.SetVolumen(Volumen);
dur = nucleo.Duracion();
pos = TimeSpan.Zero;
trackBarPosicion.Maximum = (int)dur.TotalSeconds;
timerCancion.Enabled = true;
labelDuracion.Text = (int)dur.TotalMinutes + ":" + dur.Seconds;
Text = nucleo.CancionReproduciendose();
labelDatosCancion.Text = nucleo.GetDatos();
estadoReproductor = EstadoReproductor.Reproduciendo;
buttonReproducirPausar.Text = GetTextoReproductor(estadoReproductor);
}
/// <summary>
/// Sigue el tiempo de reproduccion de la cancion en reproduccion
/// </summary>
/// <param name="sender">El objeto que invoco el evento</param>
/// <param name="e">El evento invocado</param>
private void SeguidorDeTiempoReproduccion(object sender, EventArgs e)
{
OnAvanceCancion?.Invoke(_blockAlignedStream.CurrentTime.TotalSeconds);
if ((int)Math.Ceiling(_blockAlignedStream.CurrentTime.TotalSeconds) >=
(int)Math.Ceiling(_duracionTotalDeCancionEnReproduccion))
{
_seguidorDeEventosDelReproductor.Stop();
_waveOutEvent.Stop();
_estadoReproductor = EstadoReproductor.Detenido;
OnCambioEstadoReproduccion?.Invoke(false);
if (_bufferCancion != null && _blockAlignedStream != null)
{
_bufferCancion.Dispose();
_blockAlignedStream.Dispose();
}
ReproducirSiguienteCancion();
}
}
public Reproductor()
{
InitializeComponent();
checkBoxFoobar.Visible = false;
Log.Instance.ImprimirMensaje("Iniciando reproductor", TipoMensaje.Info);
timerCancion.Enabled = false;
estadoReproductor = EstadoReproductor.Detenido;
DuracionSeleccionada = new ToolTip();
VolumenSeleccionado = new ToolTip();
Volumen = 1.0f;
trackBarVolumen.Value = 100;
duracionView = new ToolTip();
buttonAgregar.Hide();
if (!Programa.SpotifyActivado)
{
buttonSpotify.Enabled = false;
}
Icon = Properties.Resources.iconoReproductor;
GuardarHistorial = false;
if (GuardarHistorial) //sin uso
{
DateTime now = DateTime.Now;
Historial = new FileInfo("Log Musical " + now.Day + "-" + now.Month + "-" + now.Year + "-" + now.Hour + "." + now.Minute + ".txt");
NumCancion = 1;
}
if (Programa.ModoStream) //inicia el programa con solo la imperesión
{
iconoCerrar.Visible = true;
while (!Programa._spotify.cuentaLista)
{
Thread.Sleep(100);
}
ActivarSpotify();
}
else
{
iconoCerrar.Visible = false;
}
buttonTwit.Enabled = false;
}
/// <summary>
/// Pausa, Reproduce o Inicia la siguiente cancion dependiento de _estadoReproductor
/// </summary>
public void Play()
{
if (_estadoReproductor == EstadoReproductor.Reproduciendo)
{
_waveOutEvent.Pause();
_seguidorDeEventosDelReproductor.Stop();
OnCambioEstadoReproduccion?.Invoke(false);
_estadoReproductor = EstadoReproductor.Pausado;
}
else if (_estadoReproductor == EstadoReproductor.Pausado)
{
_waveOutEvent.Play();
_seguidorDeEventosDelReproductor.Start();
OnCambioEstadoReproduccion?.Invoke(true);
_estadoReproductor = EstadoReproductor.Reproduciendo;
}
else if (_estadoReproductor == EstadoReproductor.Detenido)
{
ReproducirSiguienteCancion();
}
}
/// <summary>
/// Se encarga de manejar los errores que puedan ocurrir al recuperar una cancion del servidor
/// </summary>
/// <param name="message">El mensaje que recibe del cliente de canciones</param>
private void ManejarErrores(string message)
{
if (message != "AuntenticacionFallida")
{
new MensajeEmergente().MostrarMensajeError(message);
}
else
{
new MensajeEmergente().MostrarMensajeError("No se logro logear con las credenciales proporcionadas " +
"en el inicio de sesión, si continua obteniendo este " +
"mensaje, cierre sesión y vuelva a logearse");
}
_waveOutEvent.Stop();
OnCambioEstadoReproduccion?.Invoke(false);
_seguidorDeEventosDelReproductor.Stop();
_estadoReproductor = EstadoReproductor.Detenido;
if (_bufferCancion != null && _blockAlignedStream != null)
{
_bufferCancion.Dispose();
_blockAlignedStream.Dispose();
}
ReproducirSiguienteCancion();
}
private void buttonReproducirPausar_Click(object sender, EventArgs e)
{
switch (estadoReproductor)
{
case EstadoReproductor.Reproduciendo:
if (!Spotify)
{
nucleo.Pausar();
}
else if (Spotify && EsPremium)
{
ErrorResponse err = _spotify.PausePlayback();
if (err.Error != null && err.Error.Message != null)
{
Log.ImprimirMensaje(err.Error.Message, TipoMensaje.Error);
MessageBox.Show(err.Error.Message);
}
break;
}
estadoReproductor = EstadoReproductor.Pausado;
buttonReproducirPausar.Text = "▶";
break;
case EstadoReproductor.Pausado:
if (!Spotify)
{
nucleo.Reproducir();
}
else if (Spotify && EsPremium)
{
ErrorResponse err = _spotify.ResumePlayback("", "", null, "", 0);
if (err.Error != null && err.Error.Message != null)
{
Log.ImprimirMensaje(err.Error.Message, TipoMensaje.Error);
MessageBox.Show(err.Error.Message);
}
break;
}
estadoReproductor = EstadoReproductor.Reproduciendo;
buttonReproducirPausar.Text = "❚❚";
break;
case EstadoReproductor.Detenido:
if (!Spotify)
{
nucleo.Reproducir();
}
else if (Spotify && EsPremium)
{
ErrorResponse err = _spotify.ResumePlayback("", "", null, "", 0);
if (err.Error != null && err.Error.Message != null)
{
Log.ImprimirMensaje(err.Error.Message, TipoMensaje.Error);
MessageBox.Show(err.Error.Message);
}
break;
}
estadoReproductor = EstadoReproductor.Reproduciendo;
buttonReproducirPausar.Text = "❚❚";
break;
default:
break;
}
}
private void timerCancion_Tick(object sender, EventArgs e)
{
if (estadoReproductor == EstadoReproductor.Detenido)
{
trackBarPosicion.Enabled = false;
}
else
{
trackBarPosicion.Enabled = true;
}
if (!Spotify && timerCancion.Enabled && nucleo.ComprobarSonido())
{
pos = nucleo.Posicion();
using (StreamWriter salida = new StreamWriter("np.txt"))
{
if (CancionLocalReproduciendo == null)
{
salida.WriteLine(Text);
}
else
{
salida.WriteLine(CancionLocalReproduciendo.ToString());
}
salida.Write((int)pos.TotalMinutes + ":" + pos.ToString(@"ss") + " / ");
salida.Write((int)dur.TotalMinutes + ":" + dur.ToString(@"ss"));
}
}
labelPosicion.Text = (int)pos.TotalMinutes + ":" + pos.ToString(@"ss");
if (pos > dur)
{
dur = pos;
}
if (TiempoRestante)
{
TimeSpan tRes = dur - pos;
labelDuracion.Text = "-" + (int)tRes.TotalMinutes + ":" + tRes.ToString(@"ss");
}
else
{
labelDuracion.Text = (int)dur.TotalMinutes + ":" + dur.ToString(@"ss");
}
if (nucleo.ComprobarSonido())
{
double val = pos.TotalMilliseconds / dur.TotalMilliseconds * trackBarPosicion.Maximum;
trackBarPosicion.Value = (int)val;
}
if (pos == dur)
{
estadoReproductor = EstadoReproductor.Detenido;
if (ListaReproduccion != null)
{
ListaReproduccionPuntero++;
if (!ListaReproduccion.Final(ListaReproduccionPuntero))
{
ReproducirCancion(ListaReproduccion.GetCancion(ListaReproduccionPuntero));
}
else
{
nucleo.Detener();
}
}
}
}
private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
PlaybackContext PC = (PlaybackContext)e.Result; //datos de spotify
if (PC != null && PC.Item != null) //si son válidos
{
buttonTwit.Enabled = true;
buttonAgregar.Enabled = true;
dur = new TimeSpan(0, 0, 0, 0, PC.Item.DurationMs);
trackBarPosicion.Maximum = (int)dur.TotalSeconds;
pos = new TimeSpan(0, 0, 0, 0, PC.ProgressMs);
SpotifyID = PC.Item.Id;
if (!Programa.ModoStream)
{
trackBarPosicion.Value = (int)pos.TotalSeconds;
if (PC.Item.Id != cancionReproduciendo.Id || pictureBoxCaratula.Image == null)
{
//using (StreamWriter escritor = new StreamWriter(Historial.FullName, true))
//{
// escritor.WriteLine(NumCancion + " - " + PC.Item.Artists[0].Name + " - " + PC.Item.Name);
// NumCancion++;
//}
if (!string.IsNullOrEmpty(PC.Item.Id))
{
try
{
DescargarPortada(PC.Item.Album);
pictureBoxCaratula.Image = System.Drawing.Image.FromFile("./covers/np.jpg");
}
catch (Exception)
{
pictureBoxCaratula.Image = Properties.Resources.albumdesconocido;
}
}
else
{
Log.ImprimirMensaje("Se ha detectado una canción local.", TipoMensaje.Info);
trackBarPosicion.Maximum = (int)dur.TotalSeconds;
pictureBoxCaratula.Image.Dispose();
pictureBoxCaratula.Image = Properties.Resources.albumdesconocido;
}
}
if (PC.IsPlaying)
{
estadoReproductor = EstadoReproductor.Reproduciendo;
buttonReproducirPausar.Text = "❚❚";
timerCancion.Enabled = true;
}
else
{
estadoReproductor = EstadoReproductor.Pausado;
buttonReproducirPausar.Text = "▶";
timerCancion.Enabled = false;
}
if (PC.ShuffleState)
{
checkBoxAleatorio.Checked = true;
}
else
{
checkBoxAleatorio.Checked = false;
}
cancionReproduciendo = PC.Item;
Text = PC.Item.Artists[0].Name + " - " + cancionReproduciendo.Name;
trackBarVolumen.Value = PC.Device.VolumePercent;
if (string.IsNullOrEmpty(PC.Item.Id))
{
buttonAgregar.Enabled = false;
}
else
{
buttonAgregar.Enabled = true;
}
}
using (StreamWriter salida = new StreamWriter("np.txt")) //se debería poder personalizar con filtros pero otro día
{
TimeSpan np = TimeSpan.FromMilliseconds(PC.ProgressMs);
salida.WriteLine(PC.Item.Artists[0].Name + " - " + PC.Item.Name);
salida.Write((int)np.TotalMinutes + ":" + np.ToString(@"ss") + " / ");
salida.Write((int)dur.TotalMinutes + ":" + dur.ToString(@"ss"));
}
}
else
{
buttonTwit.Enabled = false;
buttonAgregar.Enabled = false;
}
}
