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 ()=default
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}
{
}

~VersionChecker()

VersionChecker::~VersionChecker ( )

default

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

{
   const auto response {[this](const int result) {
#ifndef MIDI2LR_BETA
      if (result) {
         if (juce::URL("https://github.com/rsjaffe/MIDI2LR/releases")
                 .launchInDefaultBrowser()) { /* successfully opened browser */
            settings_manager_.SetLastVersionFound(new_version_);
         }
      }
      else { /* user doesn't want it, don't show again */
         settings_manager_.SetLastVersionFound(new_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(juce::translate("A new version of {} is available.").toStdString(),
              "MIDI2LR"),
          juce::translate("Do you want to download the latest version?") + ' '
              + IntToVersion(new_version_),
          nullptr, juce::ModalCallbackFunction::create(response));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
   }
}

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

Start()

void VersionChecker::Start

(

)

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

Stop()

void VersionChecker::Stop ( )

inlinenoexcept

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

Member Data Documentation

new_version_

int VersionChecker::new_version_ {0}

private

{0};

run_future_

std::future<void> VersionChecker::run_future_

private

settings_manager_

SettingsManager& VersionChecker::settings_manager_

private

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