audacity::cloud::audiocom::ShareAudioDialog Class Reference

#include <ShareAudioDialog.h>

Inheritance diagram for audacity::cloud::audiocom::ShareAudioDialog:

Collaboration diagram for audacity::cloud::audiocom::ShareAudioDialog:

Classes
class	ExportProgressUpdater
struct	InitialStatePanel
struct	ProgressPanel
struct	Services

Public Member Functions
	ShareAudioDialog (AudacityProject &project, AudiocomTrace, wxWindow *parent=nullptr)
	~ShareAudioDialog () override
Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()
	wxDialogWrapper (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
bool	Create (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
void	SetTitle (const TranslatableString &title)
void	SetLabel (const TranslatableString &title)
void	SetName (const TranslatableString &title)
void	SetName ()
Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&... args)
	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete
	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete
wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete
wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Private Types
using	Clock = std::chrono::steady_clock

Private Member Functions
void	Populate (ShuttleGui &s)
void	OnCancel ()
void	OnContinue ()
wxString	ExportProject ()
void	StartUploadProcess ()
void	HandleUploadSucceeded (const UploadSuccessfulPayload &payload)
void	HandleUploadFailed (const UploadFailedPayload &payload)
void	HandleExportFailure ()
void	ResetProgress ()
void	UpdateProgress (uint64_t current, uint64_t total)

Private Attributes
AudacityProject &	mProject
struct audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel	mInitialStatePanel
struct audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel	mProgressPanel
wxButton *	mContinueButton { nullptr }
wxButton *	mCancelButton { nullptr }
std::unique_ptr< Services >	mServices
const AudiocomTrace	mAudiocomTrace
std::unique_ptr< ExportProgressUpdater >	mExportProgressUpdater
Clock::time_point	mStageStartTime
Clock::time_point	mLastUIUpdateTime
int	mLastProgressValue { 0 }
wxString	mFilePath
std::function< void()>	mContinueAction
bool	mIsAuthorised { false }
bool	mInProgress { false }

Detailed Description

Definition at line 40 of file ShareAudioDialog.h.

Member Typedef Documentation

Clock

using audacity::cloud::audiocom::ShareAudioDialog::Clock = std::chrono::steady_clock

private

Definition at line 116 of file ShareAudioDialog.h.

Constructor & Destructor Documentation

ShareAudioDialog()

audacity::cloud::audiocom::ShareAudioDialog::ShareAudioDialog	(	AudacityProject &	project,
		AudiocomTrace	trace,
		wxWindow *	parent = nullptr
	)

Definition at line 168 of file ShareAudioDialog.cpp.

    : wxDialogWrapper(
         parent, wxID_ANY, XO("Share Audio"), wxDefaultPosition, { 480, 250 },
         wxDEFAULT_DIALOG_STYLE)
    , mProject(project)
    , mInitialStatePanel(*this)
    , mServices(std::make_unique<Services>())
    , mAudiocomTrace(trace)
{
   GetAuthorizationHandler().PushSuppressDialogs();
 
   ShuttleGui s(this, eIsCreating);
 
   s.StartVerticalLay();
   {
      Populate(s);
   }
   s.EndVerticalLay();
 
   Layout();
   Fit();
   Centre();
 
   const auto size = GetSize();
 
   SetMinSize({ size.x, std::min(250, size.y) });
   SetMaxSize({ size.x, -1 });
 
   mContinueAction = [this]() {
      if (mInitialStatePanel.root->IsShown())
         StartUploadProcess();
   };
 
   Bind(
      wxEVT_CHAR_HOOK,
      [this](auto& evt)
      {
         if (!IsEscapeKey(evt))
         {
            evt.Skip();
            return;
         }
 
         OnCancel();
      });
}

~ShareAudioDialog()

audacity::cloud::audiocom::ShareAudioDialog::~ShareAudioDialog ( )

override

Definition at line 216 of file ShareAudioDialog.cpp.

{
   GetAuthorizationHandler().PopSuppressDialogs();
   // Clean up the temp file when the dialog is closed
   if (!mFilePath.empty() && wxFileExists(mFilePath))
      wxRemoveFile(mFilePath);
}

References audacity::cloud::audiocom::GetAuthorizationHandler(), mFilePath, and audacity::cloud::audiocom::AuthorizationHandler::PopSuppressDialogs().

Here is the call graph for this function:

Member Function Documentation

ExportProject()

wxString audacity::cloud::audiocom::ShareAudioDialog::ExportProject ( )

private

Definition at line 313 of file ShareAudioDialog.cpp.

{
   auto& tracks = TrackList::Get(mProject);
 
   const double t0 = 0.0;
   const double t1 = tracks.GetEndTime();
 
   const int nChannels = CalculateChannels(tracks);
 
   auto hasMimeType = [](const auto&& mimeTypes, const std::string& mimeType)
   {
      return std::find(mimeTypes.begin(), mimeTypes.end(), mimeType) != mimeTypes.end();
   };
 
   const auto& registry = ExportPluginRegistry::Get();
 
   for(const auto& preferredMimeType : GetServiceConfig().GetPreferredAudioFormats())
   {
      auto config = GetServiceConfig().GetExportConfig(preferredMimeType);
      ExportProcessor::Parameters parameters;
      auto pluginIt = std::find_if(registry.begin(), registry.end(), [&](auto t)
      {
         auto [plugin, formatIndex] = t;
         parameters.clear();
         return hasMimeType(plugin->GetMimeTypes(formatIndex), preferredMimeType) &&
            plugin->ParseConfig(formatIndex, config, parameters);
      });
 
      if(pluginIt == registry.end())
         continue;
 
      const auto [plugin, formatIndex] = *pluginIt;
 
      const auto formatInfo = plugin->GetFormatInfo(formatIndex);
      const auto path = GenerateTempPath(formatInfo.extensions[0]);
 
      if(path.empty())
         continue;
 
      mExportProgressUpdater = std::make_unique<ExportProgressUpdater>(*this);
 
      auto builder = ExportTaskBuilder{}
         .SetParameters(parameters)
         .SetNumChannels(nChannels)
         .SetSampleRate(ProjectRate::Get(mProject).GetRate())
         .SetPlugin(plugin)
         .SetFileName(path)
         .SetRange(t0, t1, false);
 
      auto result = ExportResult::Error;
      ExportProgressUI::ExceptionWrappedCall([&]
      {
         auto exportTask = builder.Build(mProject);
 
         auto f = exportTask.get_future();
         std::thread(std::move(exportTask), std::ref(*mExportProgressUpdater)).detach();
 
         ExportProgressUI::ExceptionWrappedCall([&]
         {
            while(f.wait_for(std::chrono::milliseconds(50)) != std::future_status::ready)
               mExportProgressUpdater->UpdateUI();
            result = f.get();
         });
      });
 
      mExportProgressUpdater->SetResult(result);
      const auto success = result == ExportResult::Success;
      if(!success && wxFileExists(path))
         wxRemoveFile(path);
      if(success)
         return path;
   }
   return {};
}

References audacity::cloud::audiocom::anonymous_namespace{ShareAudioDialog.cpp}::CalculateChannels(), Error, ExportProgressUI::ExceptionWrappedCall(), audacity::cloud::audiocom::anonymous_namespace{ShareAudioDialog.cpp}::GenerateTempPath(), ExportPluginRegistry::Get(), ProjectRate::Get(), TrackList::Get(), audacity::cloud::audiocom::ServiceConfig::GetExportConfig(), anonymous_namespace{TimeTrack.cpp}::GetRate(), audacity::cloud::audiocom::GetServiceConfig(), mExportProgressUpdater, mProject, ExportTaskBuilder::SetFileName(), ExportTaskBuilder::SetNumChannels(), ExportTaskBuilder::SetParameters(), ExportTaskBuilder::SetPlugin(), ExportTaskBuilder::SetRange(), ExportTaskBuilder::SetSampleRate(), Success, and tracks.

Referenced by StartUploadProcess().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleExportFailure()

void audacity::cloud::audiocom::ShareAudioDialog::HandleExportFailure ( )

private

Definition at line 499 of file ShareAudioDialog.cpp.

{
   EndModal(wxID_ABORT);
 
   BasicUI::ShowErrorDialog(
      {}, XO("Export error"),
      XO("We are unable to prepare this file for uploading."), {},
      BasicUI::ErrorDialogOptions { BasicUI::ErrorDialogType::ModalError });
}

References BasicUI::ModalError, BasicUI::ShowErrorDialog(), and XO().

Referenced by StartUploadProcess().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleUploadFailed()

void audacity::cloud::audiocom::ShareAudioDialog::HandleUploadFailed ( const UploadFailedPayload &  payload )

private

Definition at line 470 of file ShareAudioDialog.cpp.

{
   EndModal(wxID_ABORT);
 
   TranslatableString message;
 
   if (!payload.message.empty())
   {
      auto details = payload.message;
 
      for (auto& err : payload.additionalErrors)
         details += " " + err.second;
 
      message = XO("Error: %s").Format(details);
   }
   else
   {
      message = XO(
         "We are unable to upload this file. Please try again and make sure to link to your audio.com account before uploading.");
   }
 
   BasicUI::ShowErrorDialog(
      {}, XO("Upload error"),
      message,
      {},
      BasicUI::ErrorDialogOptions { BasicUI::ErrorDialogType::ModalError });
 
}

References audacity::cloud::audiocom::UploadFailedPayload::additionalErrors, audacity::cloud::audiocom::UploadFailedPayload::message, BasicUI::ModalError, BasicUI::ShowErrorDialog(), and XO().

Here is the call graph for this function:

HandleUploadSucceeded()

void audacity::cloud::audiocom::ShareAudioDialog::HandleUploadSucceeded ( const UploadSuccessfulPayload &  payload )

private

Definition at line 463 of file ShareAudioDialog.cpp.

{
   EndModal(wxID_CLOSE);
   OpenInDefaultBrowser(wxString { payload.audioUrl });
}

References audacity::cloud::audiocom::UploadSuccessfulPayload::audioUrl, and BasicUI::OpenInDefaultBrowser().

Here is the call graph for this function:

OnCancel()

void audacity::cloud::audiocom::ShareAudioDialog::OnCancel ( )

private

Definition at line 270 of file ShareAudioDialog.cpp.

{
   if (mInProgress)
   {
      AudacityMessageDialog dlgMessage(
         this, XO("Are you sure you want to cancel?"), XO("Cancel upload to Audio.com"),
         wxYES_NO | wxICON_QUESTION | wxNO_DEFAULT | wxSTAY_ON_TOP);
 
      const auto result = dlgMessage.ShowModal();
 
      if (result != wxID_YES)
         return;
 
      // If export has started, notify it that it should be canceled
      if (mExportProgressUpdater)
         mExportProgressUpdater->Cancel();
   }
 
 
   // If upload was started - ask it to discard the result.
   // The result should be discarded even after the upload has finished
   if (mServices->uploadPromise)
      mServices->uploadPromise->DiscardResult();
 
   EndModal(wxID_CANCEL);
}

References mExportProgressUpdater, mInProgress, mServices, and XO().

Referenced by Populate().

Here is the call graph for this function:

Here is the caller graph for this function:

OnContinue()

void audacity::cloud::audiocom::ShareAudioDialog::OnContinue ( )

private

Definition at line 297 of file ShareAudioDialog.cpp.

{
   mContinueAction();
}

References mContinueAction.

Referenced by Populate().

Here is the caller graph for this function:

Populate()

void audacity::cloud::audiocom::ShareAudioDialog::Populate ( ShuttleGui &  s )

private

Definition at line 224 of file ShareAudioDialog.cpp.

{
   mInitialStatePanel.PopulateInitialStatePanel(s);
   mProgressPanel.PopulateProgressPanel(s);
 
   s.StartHorizontalLay(wxEXPAND, 0);
   {
      s.StartInvisiblePanel(14);
      {
         s.SetBorder(2);
         s.StartHorizontalLay(wxEXPAND, 0);
         {
            s.AddSpace(0, 0, 1);
 
            mCancelButton = s.AddButton(XXO("&Cancel"));
            mCancelButton->Bind(wxEVT_BUTTON, [this](auto) { OnCancel(); });
 
            s.AddSpace(4, 0, 0);
 
            mContinueButton = s.AddButton(XXO("C&ontinue"));
            mContinueButton->Bind(wxEVT_BUTTON, [this](auto) { OnContinue(); });
         }
         s.EndHorizontalLay();
      }
      s.EndInvisiblePanel();
   }
   s.EndHorizontalLay();
 
   const auto title = mProject.GetProjectName();
 
   if (!title.empty())
   {
      mInitialStatePanel.trackTitle->SetValue(title);
      mInitialStatePanel.trackTitle->SetInsertionPoint(title.length());
   }
 
   mContinueButton->Enable(mIsAuthorised && mInitialStatePanel.HasValidTitle());
 
   mInitialStatePanel.trackTitle->Bind(
      wxEVT_TEXT,
      [this](auto&) {
         mContinueButton->Enable(
            mIsAuthorised && mInitialStatePanel.HasValidTitle());
      });
}

References ShuttleGuiBase::AddButton(), ShuttleGui::AddSpace(), ShuttleGuiBase::EndHorizontalLay(), ShuttleGuiBase::EndInvisiblePanel(), AudacityProject::GetProjectName(), audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel::HasValidTitle(), mCancelButton, mContinueButton, mInitialStatePanel, mIsAuthorised, mProgressPanel, mProject, OnCancel(), OnContinue(), audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel::PopulateInitialStatePanel(), audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel::PopulateProgressPanel(), ShuttleGuiBase::SetBorder(), ShuttleGuiBase::StartHorizontalLay(), ShuttleGuiBase::StartInvisiblePanel(), title, audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel::trackTitle, and XXO().

Here is the call graph for this function:

ResetProgress()

void audacity::cloud::audiocom::ShareAudioDialog::ResetProgress ( )

private

Definition at line 509 of file ShareAudioDialog.cpp.

{
   mStageStartTime = Clock::now();
   mLastUIUpdateTime = mStageStartTime;
 
   mProgressPanel.elapsedTime->SetLabel(" 00:00:00");
   mProgressPanel.remainingTime->SetLabel(" 00:00:00");
   mProgressPanel.progress->SetValue(0);
 
   mLastProgressValue = 0;
 
   mExportProgressUpdater.reset();
 
   BasicUI::Yield();
}

References BasicUI::Yield().

Referenced by StartUploadProcess().

Here is the call graph for this function:

Here is the caller graph for this function:

StartUploadProcess()

void audacity::cloud::audiocom::ShareAudioDialog::StartUploadProcess ( )

private

Definition at line 388 of file ShareAudioDialog.cpp.

{
   mInProgress = true;
 
   mInitialStatePanel.root->Hide();
   mProgressPanel.root->Show();
 
   mProgressPanel.info->Hide();
 
   mContinueButton->Hide();
 
   Layout();
   Fit();
 
   ResetProgress();
 
   mFilePath = ExportProject();
 
   if(mFilePath.empty())
   {
      if(!mExportProgressUpdater ||
         mExportProgressUpdater->GetResult() != ExportResult::Cancelled)
      {
         HandleExportFailure();
      }
 
      return;
   }
 
   mProgressPanel.title->SetLabel(XO("Uploading audio...").Translation());
   ResetProgress();
 
   mServices->uploadPromise = mServices->uploadService.Upload(
      mFilePath, mInitialStatePanel.GetTrackTitle(), false,
      [this](const auto& result) {
         CallAfter(
            [this, result]()
            {
               mInProgress = false;
 
               if (result.result == UploadOperationCompleted::Result::Success)
               {
                  // Success indicates that UploadSuccessfulPayload is in the payload
                  assert(std::holds_alternative<UploadSuccessfulPayload>(result.payload));
 
                  if (
                     auto payload =
                        std::get_if<UploadSuccessfulPayload>(&result.payload))
                     HandleUploadSucceeded(*payload);
                  else
                     HandleUploadSucceeded({});
 
               }
               else if (
                  result.result != UploadOperationCompleted::Result::Aborted)
               {
                  if (
                     auto payload =
                        std::get_if<UploadFailedPayload>(&result.payload))
                     HandleUploadFailed(*payload);
                  else
                     HandleUploadFailed({});
               }
            });
      },
      [this](auto current, auto total) {
         CallAfter(
            [this, current, total]()
            {
               UpdateProgress(current, total);
            });
      },
      mAudiocomTrace);
}

References Cancelled, ExportProject(), audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel::GetTrackTitle(), HandleExportFailure(), audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel::info, mContinueButton, mExportProgressUpdater, mFilePath, mInitialStatePanel, mInProgress, mProgressPanel, mServices, ResetProgress(), audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel::root, audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel::root, audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel::title, and XO().

Here is the call graph for this function:

UpdateProgress()

void audacity::cloud::audiocom::ShareAudioDialog::UpdateProgress ( uint64_t  current, uint64_t  total  )

private

Definition at line 537 of file ShareAudioDialog.cpp.

{
   using namespace std::chrono;
 
   const auto now = Clock::now();
 
   if (current == 0)
      return;
 
   if (current > total)
      current = total;
 
   if (mLastProgressValue != current)
   {
      constexpr int scale = 10000;
 
      mLastProgressValue = static_cast<int>(current);
 
      mProgressPanel.progress->SetRange(scale);
      mProgressPanel.progress->SetValue((current * scale) / total);
 
      if (current == total && mServices->uploadPromise)
      {
         mProgressPanel.timePanel->Hide();
         mProgressPanel.title->SetLabel(XO("Finalizing upload...").Translation());
      }
   }
 
   const auto elapsedSinceUIUpdate = now - mLastUIUpdateTime;
 
   constexpr auto uiUpdateTimeout = 500ms;
 
   if (elapsedSinceUIUpdate < uiUpdateTimeout && current < total)
      return;
 
   mLastUIUpdateTime = now;
 
   const auto elapsed = duration_cast<milliseconds>(now - mStageStartTime);
 
   SetTimeLabel(mProgressPanel.elapsedTime, elapsed);
 
   const auto estimate = elapsed * total / current;
   const auto remains = estimate - elapsed;
 
   SetTimeLabel(
      mProgressPanel.remainingTime,
      std::chrono::duration_cast<std::chrono::milliseconds>(remains));
}

References audacity::cloud::audiocom::anonymous_namespace{ShareAudioDialog.cpp}::SetTimeLabel(), and XO().

Referenced by audacity::cloud::audiocom::ShareAudioDialog::ExportProgressUpdater::UpdateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mAudiocomTrace

const AudiocomTrace audacity::cloud::audiocom::ShareAudioDialog::mAudiocomTrace

private

Definition at line 111 of file ShareAudioDialog.h.

mCancelButton

wxButton* audacity::cloud::audiocom::ShareAudioDialog::mCancelButton { nullptr }

private

Definition at line 107 of file ShareAudioDialog.h.

Referenced by Populate().

mContinueAction

std::function<void()> audacity::cloud::audiocom::ShareAudioDialog::mContinueAction

private

Definition at line 124 of file ShareAudioDialog.h.

Referenced by OnContinue().

mContinueButton

wxButton* audacity::cloud::audiocom::ShareAudioDialog::mContinueButton { nullptr }

private

Definition at line 106 of file ShareAudioDialog.h.

Referenced by Populate(), and StartUploadProcess().

mExportProgressUpdater

std::unique_ptr<ExportProgressUpdater> audacity::cloud::audiocom::ShareAudioDialog::mExportProgressUpdater

private

Definition at line 114 of file ShareAudioDialog.h.

Referenced by ExportProject(), OnCancel(), and StartUploadProcess().

mFilePath

wxString audacity::cloud::audiocom::ShareAudioDialog::mFilePath

private

Definition at line 122 of file ShareAudioDialog.h.

Referenced by StartUploadProcess(), and ~ShareAudioDialog().

mInitialStatePanel

struct audacity::cloud::audiocom::ShareAudioDialog::InitialStatePanel audacity::cloud::audiocom::ShareAudioDialog::mInitialStatePanel

private

Referenced by Populate(), and StartUploadProcess().

mInProgress

bool audacity::cloud::audiocom::ShareAudioDialog::mInProgress { false }

private

Definition at line 127 of file ShareAudioDialog.h.

Referenced by OnCancel(), and StartUploadProcess().

mIsAuthorised

bool audacity::cloud::audiocom::ShareAudioDialog::mIsAuthorised { false }

private

Definition at line 126 of file ShareAudioDialog.h.

Referenced by Populate().

mLastProgressValue

int audacity::cloud::audiocom::ShareAudioDialog::mLastProgressValue { 0 }

private

Definition at line 120 of file ShareAudioDialog.h.

mLastUIUpdateTime

Clock::time_point audacity::cloud::audiocom::ShareAudioDialog::mLastUIUpdateTime

private

Definition at line 119 of file ShareAudioDialog.h.

mProgressPanel

struct audacity::cloud::audiocom::ShareAudioDialog::ProgressPanel audacity::cloud::audiocom::ShareAudioDialog::mProgressPanel

private

Referenced by Populate(), and StartUploadProcess().

mProject

AudacityProject& audacity::cloud::audiocom::ShareAudioDialog::mProject

private

Definition at line 64 of file ShareAudioDialog.h.

Referenced by ExportProject(), and Populate().

mServices

std::unique_ptr<Services> audacity::cloud::audiocom::ShareAudioDialog::mServices

private

Definition at line 110 of file ShareAudioDialog.h.

Referenced by OnCancel(), and StartUploadProcess().

mStageStartTime

Clock::time_point audacity::cloud::audiocom::ShareAudioDialog::mStageStartTime

private

Definition at line 118 of file ShareAudioDialog.h.

---

The documentation for this class was generated from the following files:

• ShareAudioDialog.h
• ShareAudioDialog.cpp