VersionChecker Class Reference

#include <VersionChecker.h>

Inheritance diagram for VersionChecker:

Public Member Functions
	VersionChecker (const VersionChecker &other)=delete
	VersionChecker (SettingsManager &settings_manager) noexcept
	VersionChecker (VersionChecker &&other)=delete
	~VersionChecker () noexcept
VersionChecker &	operator= (const VersionChecker &other)=delete
VersionChecker &	operator= (VersionChecker &&other)=delete
void	Start ()
void	Stop () noexcept

Private Member Functions
void	handleAsyncUpdate () override
void	Run () noexcept

Private Attributes
int	new_version_ {0}
std::future< void >	run_future_
SettingsManager &	settings_manager_
std::atomic< bool >	thread_should_exit_ {false}

Constructor & Destructor Documentation

VersionChecker() [1/3]

VersionChecker::VersionChecker ( SettingsManager & settings_manager )

explicitnoexcept

    : settings_manager_ {settings_manager}
{
}

References settings_manager_.

~VersionChecker()

VersionChecker::~VersionChecker ( )

noexcept

{
   try {
      // signal background task to exit
      Stop();
      // prevent a queued AsyncUpdater callback from running after destruction
      cancelPendingUpdate();
      // wait for the background task to finish if it was started
      if (run_future_.valid()) { run_future_.wait(); }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
   }
   catch (...) {
   }
}

References run_future_, and Stop().

VersionChecker() [2/3]

VersionChecker::VersionChecker ( const VersionChecker & other )

delete

VersionChecker() [3/3]

VersionChecker::VersionChecker ( VersionChecker && other )

delete

Member Function Documentation

handleAsyncUpdate()

void VersionChecker::handleAsyncUpdate ( )

overrideprivate

{
   // copy minimal state for the callback so it doesn't capture `this`
   const int reported_version {new_version_};
   SettingsManager* sm = &settings_manager_;
   const auto response {[sm, reported_version](const int result) {
#ifndef MIDI2LR_BETA
      if (result) {
         if (juce::URL("https://github.com/rsjaffe/MIDI2LR/releases").launchInDefaultBrowser()) {
            sm->SetLastVersionFound(reported_version);
         }
      }
      else {
         sm->SetLastVersionFound(reported_version);
      }
#else
      if (result) {
         std::ignore =
             juce::URL("https://github.com/rsjaffe/MIDI2LR/releases").launchInDefaultBrowser();
      }
#endif
   }};
   /*                                                                       */
   try {
      if (thread_should_exit_.load(std::memory_order_acquire)) { return; }
      juce::NativeMessageBox::showYesNoBox(juce::AlertWindow::AlertIconType::QuestionIcon,
          fmt::format(
              fmt::runtime(juce::translate("A new version of {} is available.").toStdString()),
              "MIDI2LR"),
          juce::translate("Do you want to download the latest version?") + ' '
              + IntToVersion(static_cast<unsigned int>(reported_version)),
          nullptr, juce::ModalCallbackFunction::create(response));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
   }
}

References new_version_, SettingsManager::SetLastVersionFound(), and settings_manager_.

operator=() [1/2]

VersionChecker & VersionChecker::operator= ( const VersionChecker & other )

delete

operator=() [2/2]

VersionChecker & VersionChecker::operator= ( VersionChecker && other )

delete

Run()

void VersionChecker::Run ( )

privatenoexcept

{
   try {
      const juce::URL version_url {"https://rsjaffe.github.io/MIDI2LR/version.xml"};
      const auto version_xml_element {version_url.readEntireXmlStream()};
      if (version_xml_element && !thread_should_exit_.load(std::memory_order_acquire)) {
         auto last_checked {settings_manager_.GetLastVersionFound()};
         if (version_xml_element) { new_version_ = CheckVersion(version_xml_element.get()); }
         if (last_checked == 0) {
            last_checked = std::min(new_version_, ProjectInfo::versionNumber);
            settings_manager_.SetLastVersionFound(last_checked);
         }
         LogVersion(new_version_, last_checked);
         if (new_version_ > ProjectInfo::versionNumber && new_version_ != last_checked
             && !thread_should_exit_.load(std::memory_order_acquire)) {
            triggerAsyncUpdate();
         }
      }
      else {
         rsj::Log("Unable to download MIDI2LR/version.xml and parse into valid XML document.",
             std::source_location::current());
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
   }
}

References SettingsManager::GetLastVersionFound(), new_version_, SettingsManager::SetLastVersionFound(), and settings_manager_.

Referenced by Start().

Start()

void VersionChecker::Start

(

)

{
   run_future_ = std::async(std::launch::async, [this] {
      rsj::LabelThread(MIDI2LR_UC_LITERAL("VersionChecker run thread"));
      MIDI2LR_FAST_FLOATS;
      Run();
   });
}

References Run(), and run_future_.

Stop()

void VersionChecker::Stop ( )

inlinenoexcept

{ thread_should_exit_.store(true, std::memory_order_release); }

Referenced by ~VersionChecker().

Member Data Documentation

new_version_

int VersionChecker::new_version_ {0}

private

{0};

Referenced by handleAsyncUpdate(), and Run().

run_future_

std::future<void> VersionChecker::run_future_

private

Referenced by ~VersionChecker(), and Start().

settings_manager_

SettingsManager& VersionChecker::settings_manager_

private

Referenced by VersionChecker(), handleAsyncUpdate(), and Run().

thread_should_exit_

std::atomic<bool> VersionChecker::thread_should_exit_ {false}

private

{false};

---

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

• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/VersionChecker.h
• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/VersionChecker.cpp