mirror of
https://github.com/Xaymar/obs-StreamFX
synced 2024-11-11 06:15:05 +00:00
f907fc80b0
Implements a manual and automatic update checker with support for both release and testing update channels, allowing users to stay as up to date as possible. It is fully compliant with privacy regulations around the world, as it stays completely silent and inactive until the user gives the Ok to connect to GitHub for the latest releases.
289 lines
10 KiB
C++
289 lines
10 KiB
C++
// Copyright (c) 2020 Michael Fabian Dirks <info@xaymar.com>
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
#include "ui-updater.hpp"
|
|
#include "common.hpp"
|
|
|
|
#define ST_PREFIX "<ui::updater> "
|
|
#define D_LOG_ERROR(...) DLOG_ERROR(ST_PREFIX __VA_ARGS__)
|
|
#define D_LOG_WARNING(...) DLOG_WARNING(ST_PREFIX __VA_ARGS__)
|
|
#define D_LOG_INFO(...) DLOG_INFO(ST_PREFIX __VA_ARGS__)
|
|
#ifdef _DEBUG
|
|
#define D_LOG_DEBUG(...) DLOG_DEBUG(ST_PREFIX __VA_ARGS__)
|
|
#else
|
|
#define D_LOG_DEBUG(...)
|
|
#endif
|
|
|
|
#define D_I18N_MENU_CHECKFORUPDATES "UI.Updater.Menu.CheckForUpdates"
|
|
#define D_I18N_MENU_CHECKFORUPDATES_AUTOMATICALLY "UI.Updater.Menu.CheckForUpdates.Automatically"
|
|
#define D_I18N_MENU_CHANNEL "UI.Updater.Menu.Channel"
|
|
#define D_I18N_MENU_CHANNEL_RELEASE "UI.Updater.Menu.Channel.Release"
|
|
#define D_I18N_MENU_CHANNEL_TESTING "UI.Updater.Menu.Channel.Testing"
|
|
#define D_I18N_DIALOG_TITLE "UI.Updater.Dialog.Title"
|
|
#define D_I18N_GITHUBPERMISSION_TITLE "UI.Updater.GitHubPermission.Title"
|
|
#define D_I18N_GITHUBPERMISSION_TEXT "UI.Updater.GitHubPermission.Text"
|
|
|
|
streamfx::ui::updater_dialog::updater_dialog() : QDialog(reinterpret_cast<QWidget*>(obs_frontend_get_main_window()))
|
|
{
|
|
setupUi(this);
|
|
setWindowFlag(Qt::WindowContextHelpButtonHint, false);
|
|
setWindowFlag(Qt::WindowMinimizeButtonHint, false);
|
|
setWindowFlag(Qt::WindowMaximizeButtonHint, false);
|
|
|
|
connect(ok, &QPushButton::clicked, this, &streamfx::ui::updater_dialog::on_ok);
|
|
connect(cancel, &QPushButton::clicked, this, &streamfx::ui::updater_dialog::on_cancel);
|
|
}
|
|
|
|
streamfx::ui::updater_dialog::~updater_dialog() {}
|
|
|
|
void streamfx::ui::updater_dialog::show(streamfx::update_info current, streamfx::update_info update)
|
|
{
|
|
{
|
|
std::vector<char> buf;
|
|
if (current.version_type) {
|
|
buf.resize(static_cast<size_t>(snprintf(nullptr, 0, "%" PRIu16 ".%" PRIu16 ".%" PRIu16 "%.1s%" PRIu16,
|
|
current.version_major, current.version_minor, current.version_patch,
|
|
¤t.version_type, current.version_index))
|
|
+ 1);
|
|
snprintf(buf.data(), buf.size(), "%" PRIu16 ".%" PRIu16 ".%" PRIu16 "%.1s%" PRIu16, current.version_major,
|
|
current.version_minor, current.version_patch, ¤t.version_type, current.version_index);
|
|
} else {
|
|
buf.resize(
|
|
static_cast<size_t>(snprintf(nullptr, 0, "%" PRIu16 ".%" PRIu16 ".%" PRIu16, current.version_major,
|
|
current.version_minor, current.version_patch))
|
|
+ 1);
|
|
snprintf(buf.data(), buf.size(), "%" PRIu16 ".%" PRIu16 ".%" PRIu16, current.version_major,
|
|
current.version_minor, current.version_patch);
|
|
}
|
|
currentVersion->setText(QString::fromUtf8(buf.data()));
|
|
}
|
|
|
|
{
|
|
std::vector<char> buf;
|
|
if (update.version_type) {
|
|
buf.resize(static_cast<size_t>(snprintf(nullptr, 0, "%" PRIu16 ".%" PRIu16 ".%" PRIu16 "%.1s%" PRIu16,
|
|
update.version_major, update.version_minor, update.version_patch,
|
|
&update.version_type, update.version_index))
|
|
+ 1);
|
|
snprintf(buf.data(), buf.size(), "%" PRIu16 ".%" PRIu16 ".%" PRIu16 "%.1s%" PRIu16, update.version_major,
|
|
update.version_minor, update.version_patch, &update.version_type, update.version_index);
|
|
} else {
|
|
buf.resize(static_cast<size_t>(snprintf(nullptr, 0, "%" PRIu16 ".%" PRIu16 ".%" PRIu16,
|
|
update.version_major, update.version_minor, update.version_patch))
|
|
+ 1);
|
|
snprintf(buf.data(), buf.size(), "%" PRIu16 ".%" PRIu16 ".%" PRIu16, update.version_major,
|
|
update.version_minor, update.version_patch);
|
|
}
|
|
latestVersion->setText(QString::fromUtf8(buf.data()));
|
|
|
|
{
|
|
std::vector<char> buf2;
|
|
buf2.resize(static_cast<size_t>(snprintf(nullptr, 0, D_TRANSLATE(D_I18N_DIALOG_TITLE), buf.data())) + 1);
|
|
snprintf(buf2.data(), buf2.size(), D_TRANSLATE(D_I18N_DIALOG_TITLE), buf.data());
|
|
setWindowTitle(QString::fromUtf8(buf2.data()));
|
|
}
|
|
}
|
|
|
|
_update_url = QUrl(QString::fromStdString(update.url));
|
|
|
|
QDialog::show();
|
|
}
|
|
|
|
void streamfx::ui::updater_dialog::on_ok()
|
|
{
|
|
QDesktopServices::openUrl(_update_url);
|
|
hide();
|
|
}
|
|
|
|
void streamfx::ui::updater_dialog::on_cancel()
|
|
{
|
|
hide();
|
|
}
|
|
|
|
streamfx::ui::updater::updater(QMenu* menu)
|
|
{
|
|
// Create dialog.
|
|
_dialog = new updater_dialog();
|
|
|
|
// Create GitHub message box.
|
|
_gdpr = new QMessageBox(reinterpret_cast<QWidget*>(obs_frontend_get_main_window()));
|
|
_gdpr->setWindowTitle(QString::fromUtf8(D_TRANSLATE(D_I18N_GITHUBPERMISSION_TITLE)));
|
|
_gdpr->setTextFormat(Qt::TextFormat::RichText);
|
|
_gdpr->setText(QString::fromUtf8(D_TRANSLATE(D_I18N_GITHUBPERMISSION_TEXT)));
|
|
_gdpr->setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
|
|
connect(_gdpr, &QMessageBox::buttonClicked, this, &streamfx::ui::updater::on_gdpr_button);
|
|
|
|
{ // Create the necessary menu entries.
|
|
menu->addSeparator();
|
|
|
|
// Check for Updates
|
|
_cfu = menu->addAction(QString::fromUtf8(D_TRANSLATE(D_I18N_MENU_CHECKFORUPDATES)));
|
|
connect(_cfu, &QAction::triggered, this, &streamfx::ui::updater::on_cfu_triggered);
|
|
|
|
// Automatically check for Updates
|
|
_cfu_auto = menu->addAction(QString::fromUtf8(D_TRANSLATE(D_I18N_MENU_CHECKFORUPDATES_AUTOMATICALLY)));
|
|
_cfu_auto->setCheckable(true);
|
|
connect(_cfu_auto, &QAction::toggled, this, &streamfx::ui::updater::on_cfu_auto_toggled);
|
|
|
|
// Update Channel
|
|
_channel_menu = menu->addMenu(QString::fromUtf8(D_TRANSLATE(D_I18N_MENU_CHANNEL)));
|
|
|
|
_channel_stable = _channel_menu->addAction(QString::fromUtf8(D_TRANSLATE(D_I18N_MENU_CHANNEL_RELEASE)));
|
|
_channel_stable->setCheckable(true);
|
|
|
|
_channel_preview = _channel_menu->addAction(QString::fromUtf8(D_TRANSLATE(D_I18N_MENU_CHANNEL_TESTING)));
|
|
_channel_preview->setCheckable(true);
|
|
|
|
_channel_group = new QActionGroup(_channel_menu);
|
|
_channel_group->addAction(_channel_stable);
|
|
_channel_group->addAction(_channel_preview);
|
|
connect(_channel_group, &QActionGroup::triggered, this, &streamfx::ui::updater::on_channel_group_triggered);
|
|
}
|
|
|
|
// Connect internal signals.
|
|
connect(this, &streamfx::ui::updater::autoupdate_changed, this, &streamfx::ui::updater::on_autoupdate_changed,
|
|
Qt::QueuedConnection);
|
|
connect(this, &streamfx::ui::updater::channel_changed, this, &streamfx::ui::updater::on_channel_changed,
|
|
Qt::QueuedConnection);
|
|
connect(this, &streamfx::ui::updater::update_detected, this, &streamfx::ui::updater::on_update_detected,
|
|
Qt::QueuedConnection);
|
|
connect(this, &streamfx::ui::updater::check_active, this, &streamfx::ui::updater::on_check_active,
|
|
Qt::QueuedConnection);
|
|
|
|
{ // Retrieve the updater object and listen to it.
|
|
_updater = streamfx::updater::instance();
|
|
_updater->events.automation_changed.add(std::bind(&streamfx::ui::updater::on_updater_automation_changed, this,
|
|
std::placeholders::_1, std::placeholders::_2));
|
|
_updater->events.channel_changed.add(std::bind(&streamfx::ui::updater::on_updater_channel_changed, this,
|
|
std::placeholders::_1, std::placeholders::_2));
|
|
_updater->events.refreshed.add(
|
|
std::bind(&streamfx::ui::updater::on_updater_refreshed, this, std::placeholders::_1));
|
|
if (_updater->automation()) {
|
|
if (_updater->gdpr()) {
|
|
_updater->refresh();
|
|
} else {
|
|
_gdpr->exec();
|
|
}
|
|
}
|
|
|
|
// Sync with updater information.
|
|
emit autoupdate_changed(_updater->automation());
|
|
emit channel_changed(_updater->channel());
|
|
}
|
|
}
|
|
|
|
streamfx::ui::updater::~updater() {}
|
|
|
|
void streamfx::ui::updater::on_updater_automation_changed(streamfx::updater&, bool value)
|
|
{
|
|
emit autoupdate_changed(value);
|
|
}
|
|
|
|
void streamfx::ui::updater::on_updater_channel_changed(streamfx::updater&, streamfx::update_channel channel)
|
|
{
|
|
emit channel_changed(channel);
|
|
}
|
|
|
|
void streamfx::ui::updater::on_updater_refreshed(streamfx::updater&)
|
|
{
|
|
emit check_active(false);
|
|
|
|
if (!_updater->have_update())
|
|
return;
|
|
|
|
emit update_detected();
|
|
}
|
|
|
|
void streamfx::ui::updater::on_channel_changed(streamfx::update_channel channel)
|
|
{
|
|
bool is_stable = channel == streamfx::update_channel::RELEASE;
|
|
_channel_stable->setChecked(is_stable);
|
|
_channel_preview->setChecked(!is_stable);
|
|
}
|
|
|
|
void streamfx::ui::updater::on_update_detected()
|
|
{
|
|
_dialog->show(_updater->get_current_info(), _updater->get_update_info());
|
|
}
|
|
|
|
void streamfx::ui::updater::on_autoupdate_changed(bool enabled)
|
|
{
|
|
_cfu_auto->setChecked(enabled);
|
|
}
|
|
|
|
void streamfx::ui::updater::on_gdpr_button(QAbstractButton* btn)
|
|
{
|
|
if (_gdpr->standardButton(btn) == QMessageBox::Ok) {
|
|
_updater->set_gdpr(true);
|
|
emit check_active(true);
|
|
_updater->refresh();
|
|
} else {
|
|
_updater->set_gdpr(false);
|
|
_updater->set_automation(false);
|
|
}
|
|
}
|
|
|
|
void streamfx::ui::updater::on_cfu_triggered(bool)
|
|
{
|
|
if (!_updater->gdpr()) {
|
|
_gdpr->exec();
|
|
} else {
|
|
emit check_active(true);
|
|
_updater->refresh();
|
|
}
|
|
}
|
|
|
|
void streamfx::ui::updater::on_cfu_auto_toggled(bool flag)
|
|
{
|
|
_updater->set_automation(flag);
|
|
}
|
|
|
|
void streamfx::ui::updater::on_channel_group_triggered(QAction* action)
|
|
{
|
|
if (action == _channel_stable) {
|
|
_updater->set_channel(update_channel::RELEASE);
|
|
} else {
|
|
_updater->set_channel(update_channel::TESTING);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<streamfx::ui::updater> streamfx::ui::updater::instance(QMenu* menu)
|
|
{
|
|
static std::weak_ptr<streamfx::ui::updater> _instance;
|
|
static std::mutex _lock;
|
|
|
|
auto lock = std::lock_guard<std::mutex>(_lock);
|
|
if (_instance.expired() && menu) {
|
|
auto ptr = std::make_shared<streamfx::ui::updater>(menu);
|
|
_instance = ptr;
|
|
return ptr;
|
|
} else {
|
|
return _instance.lock();
|
|
}
|
|
}
|
|
|
|
void streamfx::ui::updater::on_check_active(bool active)
|
|
{
|
|
_cfu->setEnabled(!active);
|
|
_channel_group->setEnabled(!active);
|
|
_channel_preview->setEnabled(!active);
|
|
_channel_stable->setEnabled(!active);
|
|
_channel_menu->setEnabled(!active);
|
|
}
|