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"); }