private async void ButtonDownloadTrack_Click(object sender, RoutedEventArgs e)
{
var trackAux = (Track)datagrid_Track.SelectedItem;
if (trackAux != null)
{
try {
using (FileStream fs = File.Create("..\\LocalTracks\\" + trackAux.StoragePath + ".mp3")) {
RequestTrackAudio newRequestTrackAudio = new RequestTrackAudio();
newRequestTrackAudio.Filename = trackAux.StoragePath;
TrackAudio newTrackAudio = await Session.streamingServerConnection.streamingService.GetTrackAudioAsync(newRequestTrackAudio);
fs.Write(newTrackAudio.Song, 0, newTrackAudio.Song.Length);
textBlock_Message.Text = "*Track has been download";
}
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}
else
{
textBlock_Message.Text = "*Select a track";
}
}
private async void SavePersonalTrack()
{
PersonalTrack personalTrack = new PersonalTrack(null, SingletonSesion.GetSingletonSesion().account.idAccount, TextBox_title_personal_track.Text, TextBox_gender_personal_track.Text, TextBox_album_personal_track.Text, 100, null, false, 0);
try
{
personalTrack = await PersonalTrackRepository.CreatePersonalTrack(personalTrack);
TrackAudio trackAudio = new TrackAudio()
{
IdTrack = personalTrack.idPersonalTrack,
TrackName = personalTrack.title,
Audio = GetTrackBytes()
};
var result = await RpcStreamingService.UploadPersonalTrack(trackAudio);
if (result)
{
MessageBox.Show("Track uploaded");
Window.GetWindow(this).Close();
}
else
{
MessageBox.Show("Connection error", "Please try again");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private async void AddSingleTrack(short idNewAlbum, List <ContentCreator> contentCreators)
{
int n = random.Next();
string fileName = String.Concat(textBox_SingleTrackTitle.Text, n);
Track newTrack = new Track();
newTrack.TrackNumber = 1;
newTrack.DurationSeconds = duration;
newTrack.StoragePath = fileName;
Console.WriteLine(newTrack.StoragePath);
newTrack.Title = textBox_SingleTrackTitle.Text;
newTrack.Gender = (MusicGender)Enum.Parse(typeof(MusicGender), comboBox_SingleTrackGender.Text);
await Session.serverConnection.trackService.AddTrackToAlbumAsync(idNewAlbum, newTrack, Session.contentCreator.IdContentCreator);
if (comboBox_SingleFeaturing.SelectedIndex != -1)
{
foreach (ContentCreator contentCreatorAux in contentCreators)
{
if (comboBox_SingleFeaturing.SelectedItem.ToString() == contentCreatorAux.StageName)
{
await Session.serverConnection.trackService.AddFeaturingTrackAsync(idNewAlbum, contentCreatorAux.IdContentCreator);
}
}
}
TrackAudio newTrackAudio = new TrackAudio();
newTrackAudio.Filename = fileName;
newTrackAudio.Song = fileBytes;
await Session.streamingServerConnection.streamingService.UploadTrackAsync(newTrackAudio);
}
private async void AddAlbumTrack(short idNewAlbum, List <Track> albumTracks)
{
for (int n = 0; n <= 4; n++)
{
TrackAudio newTrackAudio = new TrackAudio();
await Session.serverConnection.trackService.AddTrackToAlbumAsync(idNewAlbum, albumTracks[n], Session.contentCreator.IdContentCreator);
newTrackAudio.Filename = albumTracks[n].StoragePath;
newTrackAudio.Song = audioBytes[n];
await Session.streamingServerConnection.streamingService.UploadTrackAsync(newTrackAudio);
}
}
public static async Task <Boolean> UploadPersonalTrack(TrackAudio trackAudio)
{
try
{
await client.UploadPersonalTrackAsync(trackAudio);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public static async Task <TrackUploaded> UploadTrack(TrackAudio trackAudio)
{
TrackUploaded trackUploaded;
try
{
trackUploaded = await client.UploadTrackAsync(trackAudio);
}
catch (Exception ex)
{
throw ex;
}
return(trackUploaded);
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
TrackAudio = new TrackAudio();
await TrackAudio.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task <bool> AddLocalTrack()
{
LocalTrack localTrack = new LocalTrack()
{
IdConsumer = Session.consumer.IdConsumer,
ArtistName = TextBox_ArtistNameLocalTrack.Text,
Title = TextBox_TitleLocalTrack.Text,
FileName = GenerateFileName()
};
await Session.serverConnection.trackService.AddLocalTrackAsync(localTrack);
TrackAudio trackAudio = new TrackAudio()
{
Filename = localTrack.FileName,
Song = GetTrackBytes()
};
return(await Session.streamingServerConnection.streamingService.UploadTrackAsync(trackAudio));
}
public static async Task <bool> UploadTrackAsync(Track track)
{
try {
RequestTrackAudio requestTrackAudio = new RequestTrackAudio();
requestTrackAudio.Filename = track.StoragePath;
TrackAudio trackAudio = await Session.streamingServerConnection.streamingService.GetTrackAudioAsync(requestTrackAudio);
byte[] bytes = trackAudio.Song;
StreamingPlayer.StopPlayer();
Mp3FileReader mp3Reader = new Mp3FileReader(new MemoryStream(bytes));
waveStream = new WaveChannel32(mp3Reader);
waveOutEvent.Init(waveStream);
isTrackReady = true;
StreamingPlayer.StartPlayer();
return(true);
} catch (Exception ex) {
Console.WriteLine(ex);
return(false);
}
}
private async void SaveAlbum()
{
Album album = new Album()
{
title = TextBox_title_album.Text,
cover = Utils.Encoder.EncodeBase64(absolutePathCover),
publication = "2020-06-23",
recordCompany = TextBox_company_album.Text,
idMusicGender = 15,
idAlbumType = GetAlbumType(),
idArtist = SingletonArtist.GetSingletonArtist().idArtist,
};
album.tracks = this.tracks;
album = await AlbumRepository.CreateAlbum(album);
for (int i = 0; i < album.tracks.Count; i++)
{
TrackAudio trackAudio = new TrackAudio()
{
IdTrack = album.tracks[i].idTrack,
TrackName = album.tracks[i].title,
Audio = GetTrackBytes(filePaths[i])
};
try
{
await RpcStreamingService.UploadTrack(trackAudio);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Please relod");
}
}
MessageBox.Show("Album created");
NavigationService.Navigate(new ContentCreatorPage());
}
public async Task <TrackUploaded> UploadTrackAsync(TrackAudio trackAudio, CancellationToken cancellationToken = default(CancellationToken))
{
await OutputProtocol.WriteMessageBeginAsync(new TMessage("UploadTrack", TMessageType.Call, SeqId), cancellationToken);
var args = new UploadTrackArgs();
args.TrackAudio = trackAudio;
await args.WriteAsync(OutputProtocol, cancellationToken);
await OutputProtocol.WriteMessageEndAsync(cancellationToken);
await OutputProtocol.Transport.FlushAsync(cancellationToken);
var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
if (msg.Type == TMessageType.Exception)
{
var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
throw x;
}
var result = new UploadTrackResult();
await result.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
if (result.__isset.success)
{
return(result.Success);
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "UploadTrack failed: unknown result");
}
