UpdateManager Class Reference

A class that managing of updates. More...

#include <UpdateManager.h>

Inheritance diagram for UpdateManager:

Collaboration diagram for UpdateManager:

Public Member Functions
	UpdateManager ()=default
void	GetUpdates (bool ignoreNetworkErrors, bool configurableNotification)
VersionPatch	GetVersionPatch () const

Static Public Member Functions
static UpdateManager &	GetInstance ()
static void	Start (bool suppressModal)

Private Member Functions
void	OnTimer (wxTimerEvent &event)
bool	IsTimeForUpdatesChecking ()
	Scheduling update time for avoiding multiplying update notifications. More...

Private Attributes
UpdateDataParser	mUpdateDataParser
VersionPatch	mVersionPatch
wxTimer	mTimer
std::unique_ptr< BasicUI::ProgressDialog >	mProgressDialog
std::string	mAudacityInstallerPath
std::ofstream	mAudacityInstaller
std::mutex	mUpdateMutex
bool	mOnProgress { false }

Detailed Description

A class that managing of updates.

Opt-in request and show update dialog by the scheduled time. Have a built-in check that allows avoiding multiplying update notifications when multiple Audacity windows are shown.

Definition at line 33 of file UpdateManager.h.

Constructor & Destructor Documentation

UpdateManager()

UpdateManager::UpdateManager ( )

default

Member Function Documentation

GetInstance()

UpdateManager & UpdateManager::GetInstance ( )

static

Definition at line 53 of file UpdateManager.cpp.

{
    static UpdateManager updateManager;
 
    return updateManager;
}

Referenced by Start().

Here is the caller graph for this function:

GetUpdates()

void UpdateManager::GetUpdates	(	bool	ignoreNetworkErrors,
		bool	configurableNotification
	)

Definition at line 92 of file UpdateManager.cpp.

{
#if AUDACITY_BUILD_LEVEL == 0
   const auto url = "https://updates.audacityteam.org/builds/alpha.xml";
#elif AUDACITY_BUILD_LEVEL == 1
   const auto url = "https://updates.audacityteam.org/builds/beta.xml";
#else
   const auto url = "https://updates.audacityteam.org/feed/latest.xml";
#endif
 
    const audacity::network_manager::Request request(url);
    auto response = audacity::network_manager::NetworkManager::GetInstance().doGet(request);
 
    response->setRequestFinishedCallback([response, ignoreNetworkErrors, configurableNotification, this](audacity::network_manager::IResponse*) {
        
        // We don't' want to duplicate the updates checking if that already launched.
        {
            std::lock_guard<std::mutex> lock(mUpdateMutex);
            if (mOnProgress)
            {
                response->abort();
                return;
            }
            mOnProgress = true;
        }
 
        using namespace BasicUI;
        auto gAudioIO = AudioIO::Get();
        if (response->getError() != audacity::network_manager::NetworkError::NoError)
        {
           if (!ignoreNetworkErrors)
           {
              gAudioIO->CallAfterRecording([] {ShowErrorDialog( {},
                 XC("Error checking for update", "update dialog"),
                 XC("Unable to connect to Audacity update server.", "update dialog"),
                 wxString(),
                 ErrorDialogOptions{ ErrorDialogType::ModalErrorReport });
              });
           }
           
           mOnProgress = false;
           return;
        }
 
        if (!mUpdateDataParser.Parse(response->readAll<VersionPatch::UpdateDataFormat>(), &mVersionPatch))
        {
           if (!ignoreNetworkErrors)
           {
              gAudioIO->CallAfterRecording([] {ShowErrorDialog( {},
                 XC("Error checking for update", "update dialog"),
                 XC("Update data was corrupted.", "update dialog"),
                 wxString(),
                 ErrorDialogOptions{ ErrorDialogType::ModalErrorReport });
              });
           }
           
           mOnProgress = false;
           return;
        }
 
#if UPDATE_LOCAL_TESTING == 0
        if (mVersionPatch.version > CurrentBuildVersion())
#endif
        {
            gAudioIO->CallAfterRecording([this, ignoreNetworkErrors, configurableNotification] {
                UpdatePopupDialog dlg(nullptr, mVersionPatch, configurableNotification);
                const int code = dlg.ShowModal();
 
                if (code == wxID_YES)
                {
                    const audacity::network_manager::Request downloadRequest(mVersionPatch.download.ToStdString());
                    auto downloadResponse = audacity::network_manager::NetworkManager::GetInstance().doGet(downloadRequest);
 
                    // Called once, when downloading is real will finish.
                    downloadResponse->setRequestFinishedCallback([downloadResponse, ignoreNetworkErrors, this](audacity::network_manager::IResponse*) {
                        // First - close all opened resources.
                        wxTheApp->CallAfter([this]{ mProgressDialog.reset(); });
                        
                        if (mAudacityInstaller.is_open())
                            mAudacityInstaller.close();
                        
                        if (downloadResponse->getError() != audacity::network_manager::NetworkError::NoError)
                        {
                            if (!ignoreNetworkErrors)
                            {
                                wxTheApp->CallAfter([] {ShowErrorDialog( {},
                                  XC("Error downloading update", "update dialog"),
                                  XC("Can't open the Audacity download link.", "update dialog"),
                                  wxString(),
                                  ErrorDialogOptions{ ErrorDialogType::ModalErrorReport });
                               });
                            }
 
                            mOnProgress = false;
                            return;
                        }
                        
                        const wxPlatformInfo& info = wxPlatformInfo::Get();
                        if ((info.GetOperatingSystemId() & wxOS_WINDOWS) ||
                            info.GetOperatingSystemId() & wxOS_MAC)
                        {
                            if (wxFileName(mAudacityInstallerPath).Exists())
                            {
                                std::string cmd = info.GetOperatingSystemId() & wxOS_MAC ? "Open " + mAudacityInstallerPath : mAudacityInstallerPath;
                                wxTheApp->CallAfter([cmd] { wxExecute(cmd, wxEXEC_ASYNC); });
                            }
                        }
                        
                        mOnProgress = false;
                        }
                    );
 
                    auto audacityPatchFilename = wxFileName(mVersionPatch.download).GetName();
 
                    mProgressDialog = BasicUI::MakeProgress(XO("Audacity update"), XO("Downloading %s").Format(audacityPatchFilename));
                    wxASSERT(mProgressDialog);
                    
                    wxString installerExtension;
                    const wxPlatformInfo& info = wxPlatformInfo::Get();
                    if (info.GetOperatingSystemId() & wxOS_WINDOWS)
                        installerExtension = "exe";
                    else if(info.GetOperatingSystemId() & wxOS_MAC)
                        installerExtension = "dmg";
 
                    mAudacityInstallerPath = wxFileName(
                        wxStandardPaths::Get().GetUserDir(wxStandardPaths::Dir_Downloads), audacityPatchFilename, installerExtension)
                        .GetFullPath()
                        .ToStdString();
 
                    mAudacityInstaller.open(mAudacityInstallerPath, std::ios::binary);
                    
                    // Called each time, since downloading for update progress status.
                    downloadResponse->setDownloadProgressCallback(
                        [this](int64_t current, int64_t expected) {
 
                        wxTheApp->CallAfter([this, current, expected]{
                            if(mProgressDialog != nullptr)
                                mProgressDialog->Poll(current, expected);
                        });
                    }
                    );
 
                    // Called each time, since downloading for get data.
                    downloadResponse->setOnDataReceivedCallback([downloadResponse, this](audacity::network_manager::IResponse*) {
                        if (downloadResponse->getError() == audacity::network_manager::NetworkError::NoError)
                        {
                            std::vector<char> buffer(downloadResponse->getBytesAvailable());
 
                            size_t bytes = downloadResponse->readData(buffer.data(), buffer.size());
                            
                            if (mAudacityInstaller.is_open())
                                mAudacityInstaller.write(buffer.data(), buffer.size());
                        }
                        }
                    );
 
                }
                else if (code == wxID_NO)
                {
                    mOnProgress = false;
                }
            });
        }
#if UPDATE_LOCAL_TESTING == 0
        else // mVersionPatch.version > CurrentBuildVersion()
        {
            // That also shows, that updates checking was called manually from menu.
            if (!configurableNotification)
            {
                gAudioIO->CallAfterRecording([] {
                    NoUpdatesAvailableDialog(nullptr).ShowModal();
                    });
            }
            
            mOnProgress = false;
        }
#endif
    });
}

References CurrentBuildVersion(), audacity::network_manager::NetworkManager::doGet(), VersionPatch::download, AudioIO::Get(), BasicUI::Get(), audacity::network_manager::NetworkManager::GetInstance(), BasicUI::MakeProgress(), mAudacityInstaller, mAudacityInstallerPath, mOnProgress, mProgressDialog, mUpdateDataParser, mUpdateMutex, mVersionPatch, audacity::network_manager::NoError, UpdateDataParser::Parse(), BasicUI::ShowErrorDialog(), VersionPatch::version, XC, and XO().

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

GetVersionPatch()

VersionPatch UpdateManager::GetVersionPatch

(

)

const

Definition at line 87 of file UpdateManager.cpp.

{
    return mVersionPatch;
}

References mVersionPatch.

IsTimeForUpdatesChecking()

bool UpdateManager::IsTimeForUpdatesChecking ( )

private

Scheduling update time for avoiding multiplying update notifications.

Definition at line 288 of file UpdateManager.cpp.

{
    // We use atoll here, so there is no need to handle the exception,
    // if prefsUpdateScheduledTime is corrupted.
    // atoll will return 0 on failure, which suits us well.
    const TimePoint nextUpdatesCheckingTime(std::chrono::milliseconds(
       atoll(gPrefs->Read(prefsUpdateScheduledTime, "0").c_str())));
 
    // Get current time
    const TimePoint currentTime = Clock::now();
 
    // If next update time 0 or less then current time -> show update dialog,
    // else this condition allow us to avoid from duplicating update notifications.
    if (nextUpdatesCheckingTime < currentTime)
    {
 
        // Round down the nextUpdatesChecking time to a day.
        // This is required to ensure, that update is 
        // checked daily
        using DayDuration =
          std::chrono::duration<int32_t, std::ratio<60 * 60 * 24>>;
 
        const auto postponeUpdateUntil =
          std::chrono::time_point_cast<DayDuration>(
           currentTime) + DayDuration(1);
 
        const std::chrono::milliseconds postponeUpdateUntilMS(
           postponeUpdateUntil.time_since_epoch());
 
        gPrefs->Write(
           prefsUpdateScheduledTime,
           wxString(std::to_string(postponeUpdateUntilMS.count())));
 
        gPrefs->Flush();
 
        return true;
    }
 
    return false;
}

References audacity::BasicSettings::Flush(), gPrefs, prefsUpdateScheduledTime, audacity::BasicSettings::Read(), and audacity::BasicSettings::Write().

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTimer()

void UpdateManager::OnTimer ( wxTimerEvent &  event )

private

Definition at line 272 of file UpdateManager.cpp.

{
    bool updatesCheckingEnabled = DefaultUpdatesCheckingFlag->Read();
 
#if UPDATE_LOCAL_TESTING == 0
    if (updatesCheckingEnabled && IsTimeForUpdatesChecking())
#endif
    {
        GetUpdates(true, true);
    }
 
    mTimer.StartOnce(std::chrono::duration_cast<std::chrono::milliseconds>(
                        updatesCheckInterval)
                        .count());
}

References DefaultUpdatesCheckingFlag, GetUpdates(), IsTimeForUpdatesChecking(), mTimer, and updatesCheckInterval.

Here is the call graph for this function:

Start()

void UpdateManager::Start ( bool  suppressModal )

static

Definition at line 60 of file UpdateManager.cpp.

{
    auto& instance = GetInstance();
 
    // Show the dialog only once. 
    if (!suppressModal && !prefUpdatesNoticeShown.Read())
    {
        // DefaultUpdatesCheckingFlag survives the "Reset Preferences"
        // action, so check, if the updates were previously disabled as well.
        if (DefaultUpdatesCheckingFlag->Read())
        {
            UpdateNoticeDialog notice(nullptr);
 
            notice.ShowModal();
        }
 
        prefUpdatesNoticeShown.Write(true);
        gPrefs->Flush();
    }
 
    static std::once_flag flag;
    std::call_once(flag, [&instance] {
        instance.mTimer.SetOwner(&instance, ID_TIMER);
        instance.mTimer.StartOnce(1);
        });
}

References DefaultUpdatesCheckingFlag, flag, audacity::BasicSettings::Flush(), GetInstance(), gPrefs, ID_TIMER, prefUpdatesNoticeShown, Setting< T >::Read(), and Setting< T >::Write().

Referenced by AudacityApp::InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mAudacityInstaller

std::ofstream UpdateManager::mAudacityInstaller

private

Definition at line 59 of file UpdateManager.h.

Referenced by GetUpdates().

mAudacityInstallerPath

std::string UpdateManager::mAudacityInstallerPath

private

Definition at line 58 of file UpdateManager.h.

Referenced by GetUpdates().

mOnProgress

bool UpdateManager::mOnProgress { false }

private

Definition at line 62 of file UpdateManager.h.

Referenced by GetUpdates().

mProgressDialog

std::unique_ptr<BasicUI::ProgressDialog> UpdateManager::mProgressDialog

private

Definition at line 56 of file UpdateManager.h.

Referenced by GetUpdates().

mTimer

wxTimer UpdateManager::mTimer

private

Definition at line 49 of file UpdateManager.h.

Referenced by OnTimer().

mUpdateDataParser

UpdateDataParser UpdateManager::mUpdateDataParser

private

Definition at line 46 of file UpdateManager.h.

Referenced by GetUpdates().

mUpdateMutex

std::mutex UpdateManager::mUpdateMutex

private

Definition at line 61 of file UpdateManager.h.

Referenced by GetUpdates().

mVersionPatch

VersionPatch UpdateManager::mVersionPatch

private

Definition at line 47 of file UpdateManager.h.

Referenced by GetUpdates(), and GetVersionPatch().

---

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

• UpdateManager.h
• UpdateManager.cpp