mirror of
https://github.com/WiVRn/WiVRn.git
synced 2026-11-20 09:01:39 -08:00
721 lines
23 KiB
C++
721 lines
23 KiB
C++
/*
|
|
* WiVRn VR streaming
|
|
* Copyright (C) 2024 Guillaume Meunier <[email protected]>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "wizard.h"
|
|
|
|
#include <QClipboard>
|
|
#include <QDesktopServices>
|
|
#include <QFileInfo>
|
|
#include <QMessageBox>
|
|
#include <QMetaEnum>
|
|
#include <QNetworkAccessManager>
|
|
#include <QNetworkReply>
|
|
#include <QNetworkRequest>
|
|
#include <QProcess>
|
|
#include <QSaveFile>
|
|
#include <QScrollBar>
|
|
#include <QStandardPaths>
|
|
#include <QUrl>
|
|
#include <QWizard>
|
|
#include <algorithm>
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include "adb.h"
|
|
#include "gui_config.h"
|
|
#include "ui_wizard.h"
|
|
#include "version.h"
|
|
#include "wivrn_server.h"
|
|
#include <filesystem>
|
|
#include <regex>
|
|
|
|
using namespace Qt::Literals::StringLiterals;
|
|
|
|
enum class wizard_page
|
|
{
|
|
select_headset_model,
|
|
sideload_download,
|
|
sideload_devmode,
|
|
sideload_install,
|
|
connect_hmd,
|
|
start_game
|
|
};
|
|
|
|
struct headset
|
|
{
|
|
QString name;
|
|
QString devmode_url;
|
|
QString store_name;
|
|
QString store_url;
|
|
};
|
|
|
|
static const std::vector<headset> headsets_info = {
|
|
// clang-format off
|
|
{"HTC Vive Focus 3", "https://developer.vive.com/resources/hardware-guides/vive-focus-specs-user-guide/how-do-i-put-focus-developer-mode/"},
|
|
{"HTC Vive XR Elite", "https://developer.vive.com/resources/hardware-guides/vive-focus-specs-user-guide/how-do-i-put-focus-developer-mode/"},
|
|
{"Meta Quest 1", "https://developers.meta.com/horizon/documentation/native/android/mobile-device-setup/#enable-developer-mode"},
|
|
{"Meta Quest 2", "https://developers.meta.com/horizon/documentation/native/android/mobile-device-setup/#enable-developer-mode", "Meta Store", "https://www.meta.com/experiences/7959676140827574/"},
|
|
{"Meta Quest 3", "https://developers.meta.com/horizon/documentation/native/android/mobile-device-setup/#enable-developer-mode", "Meta Store", "https://www.meta.com/experiences/7959676140827574/"},
|
|
{"Meta Quest Pro", "https://developers.meta.com/horizon/documentation/native/android/mobile-device-setup/#enable-developer-mode", "Meta Store", "https://www.meta.com/experiences/7959676140827574/"},
|
|
{"Pico Neo 4", "https://developer.picoxr.com/document/unreal/test-and-build/#Enable%20developer%20mode"},
|
|
// clang-format on
|
|
};
|
|
|
|
static constexpr int role_devmode_url = Qt::UserRole + 1;
|
|
static constexpr int role_store_name = Qt::UserRole + 2;
|
|
static constexpr int role_store_url = Qt::UserRole + 3;
|
|
|
|
// #define TEST 1 // Not in the WiVRn-APK repo
|
|
// #define TEST 2 // In the WiVRn-APK repo, not a tagged version
|
|
// #define TEST 3 // Current version
|
|
// #define TEST 4 // Old version
|
|
|
|
#if !defined(TEST) || TEST == 0 // Normal case
|
|
static const std::string git_version = wivrn::git_version;
|
|
static const std::string git_commit = wivrn::git_commit;
|
|
#elif TEST == 1
|
|
static const std::string git_version = "v0.19.1-60-g66ce2c5";
|
|
static const std::string git_commit = "66ce2c547dedf9b320af677ed42f32f361b32832";
|
|
#elif TEST == 2
|
|
static const std::string git_version = "v0.19.1-59-g0d62929";
|
|
static const std::string git_commit = "554c0f7ad647d9cd66e380f567f2e842fff6a27a";
|
|
#elif TEST == 3
|
|
static const std::string git_version = "v0.19.1";
|
|
static const std::string git_commit = "bcffadcd4e043d7bacd700b1331c2e98f96ca178";
|
|
#elif TEST == 4
|
|
static const std::string git_version = "v0.19";
|
|
static const std::string git_commit = "d0014823480bc0e54594b74d2475882554ed5829";
|
|
#endif
|
|
|
|
wizard::wizard() :
|
|
server(new wivrn_server(this))
|
|
{
|
|
ui = new Ui::Wizard;
|
|
ui->setupUi(this);
|
|
|
|
retranslate();
|
|
|
|
connect(this, &QWizard::currentIdChanged, this, &wizard::on_page_changed);
|
|
connect(this, &QWizard::customButtonClicked, this, &wizard::on_custom_button_clicked);
|
|
|
|
connect(ui->copy_steam_command, &QPushButton::clicked, this, [&]() {
|
|
QGuiApplication::clipboard()->setText(ui->label_steam_command->text());
|
|
});
|
|
|
|
connect(server, &wivrn_server::headsetConnectedChanged, this, &wizard::on_headset_connected_changed);
|
|
|
|
connect(ui->button_cancel_download, &QPushButton::clicked, this, &wizard::cancel_download);
|
|
|
|
connect(server, &wivrn_server::steamCommandChanged, this, [this](QString value) {
|
|
ui->label_steam_command->setText(value);
|
|
});
|
|
ui->label_steam_command->setText(server->steamCommand());
|
|
|
|
connect(server, &wivrn_server::pinChanged, this, &wizard::on_pin_changed);
|
|
on_pin_changed(server->pin());
|
|
|
|
setPixmap(WatermarkPixmap, QPixmap(":/images/wivrn.svg"));
|
|
for (const headset & i: headsets_info)
|
|
{
|
|
auto item = new QStandardItem(i.name);
|
|
|
|
item->setData(i.devmode_url, role_devmode_url);
|
|
item->setData(i.store_name, role_store_name);
|
|
item->setData(i.store_url, role_store_url);
|
|
|
|
headsets.appendRow(item);
|
|
}
|
|
headsets.appendRow(new QStandardItem(tr("Other"))); // TODO retranslatable
|
|
|
|
ui->combo_hmd_model->setModel(&headsets);
|
|
ui->combo_hmd_model->setCurrentIndex(-1);
|
|
connect(ui->combo_hmd_model, &QComboBox::currentIndexChanged, this, &wizard::update_welcome_page);
|
|
connect(ui->check_sideload, &QCheckBox::clicked, this, &wizard::update_welcome_page);
|
|
|
|
setWindowModality(Qt::WindowModality::ApplicationModal);
|
|
|
|
if (std::regex_match(git_version, std::regex(".*-g[0-9a-f]+")))
|
|
{
|
|
apk_file.setFileName(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/wivrn-" + QString::fromStdString(git_commit) + ".apk");
|
|
|
|
qDebug() << "Not a tagged version" << git_version.c_str();
|
|
|
|
ui->label_release_info->setText(
|
|
tr("This is not a tagged release.") +
|
|
"\n" +
|
|
tr("If you install the headset app from the store, it might not be compatible with this server.") +
|
|
"\n" +
|
|
tr("If you install the headset app manually, this wizard will download the version that matches the dashboard."));
|
|
|
|
std::string url = "https://api.github.com/repos/WiVRn/WiVRn-APK/releases/tags/apk-" + git_commit;
|
|
qDebug() << "Downloading metadata from" << url.c_str();
|
|
|
|
apk_release_reply = manager.get(QNetworkRequest{QUrl{url.c_str()}});
|
|
connect(apk_release_reply, &QNetworkReply::finished, this, &wizard::on_apk_release_finished);
|
|
}
|
|
else
|
|
{
|
|
apk_file.setFileName(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/wivrn-" + QString::fromStdString(git_version) + ".apk");
|
|
|
|
qDebug() << "Tagged version" << git_version.c_str();
|
|
|
|
// Get the current release information
|
|
std::string url = "https://api.github.com/repos/WiVRn/WiVRn/releases/tags/" + git_version;
|
|
qDebug() << "Downloading metadata from" << url.c_str();
|
|
apk_release_reply = manager.get(QNetworkRequest{QUrl{url.c_str()}});
|
|
connect(apk_release_reply, &QNetworkReply::finished, this, &wizard::on_apk_release_finished);
|
|
|
|
// Get the latest release information
|
|
latest_release_reply = manager.get(QNetworkRequest{QUrl{"https://api.github.com/repos/WiVRn/WiVRn/releases/latest"}});
|
|
connect(latest_release_reply, &QNetworkReply::finished, this, &wizard::on_latest_release_finished);
|
|
}
|
|
|
|
// Detect connected android devices
|
|
connect(&adb_service, &adb::android_devices_changed, this, &wizard::on_android_device_list_changed);
|
|
on_android_device_list_changed(adb_service.devices());
|
|
|
|
connect(ui->list_devices, &QListWidget::itemSelectionChanged, this, &wizard::on_selected_android_device_changed);
|
|
}
|
|
|
|
void wizard::on_latest_release_finished()
|
|
{
|
|
disconnect(latest_release_reply, &QNetworkReply::finished, this, &wizard::on_latest_release_finished);
|
|
|
|
// By default, assume this is the latest release
|
|
latest_release = git_version;
|
|
|
|
try
|
|
{
|
|
if (latest_release_reply->error())
|
|
throw std::runtime_error(latest_release_reply->errorString().toStdString());
|
|
|
|
auto json = nlohmann::json::parse(latest_release_reply->readAll());
|
|
|
|
latest_release = json["tag_name"];
|
|
|
|
if (latest_release == git_version)
|
|
{
|
|
// This is already the latest release
|
|
ui->label_release_info->setText(tr("This is the latest WiVRn release."));
|
|
}
|
|
else
|
|
{
|
|
ui->label_release_info->setText(
|
|
tr("A new release is available (%1 → %2).").arg(QString::fromLatin1(git_version)).arg(QString::fromLatin1(latest_release)) +
|
|
"\n" +
|
|
tr("If you install the headset app from the store, it might not be compatible with this server.") +
|
|
"\n" +
|
|
tr("If you install the headset app manually, this wizard will download the version that matches the dashboard."));
|
|
}
|
|
}
|
|
catch (std::exception & e)
|
|
{
|
|
qWarning() << "Cannot get latest release: " << e.what();
|
|
ui->label_release_info->setText(tr("Cannot get latest release: %1").arg(e.what()));
|
|
}
|
|
|
|
latest_release_reply->deleteLater();
|
|
latest_release_reply = nullptr;
|
|
update_welcome_page();
|
|
}
|
|
|
|
void wizard::on_apk_release_finished()
|
|
{
|
|
disconnect(apk_release_reply, &QNetworkReply::finished, this, &wizard::on_apk_release_finished);
|
|
|
|
try
|
|
{
|
|
auto error = apk_release_reply->error();
|
|
|
|
if (error == QNetworkReply::NetworkError::ContentNotFoundError)
|
|
{
|
|
ui->label_release_info->setText(
|
|
"<html><head/><body><p>" +
|
|
tr("There is no precompiled APK for this version.") +
|
|
"</p>\n<p>" +
|
|
tr("Follow the <a href=\"https://github.com/WiVRn/WiVRn/blob/master/docs/building.md#client-headset\"><span style=\"text-decoration: underline; color:#2980b9;\">documentation</span></a> to build your own client.") +
|
|
"</p></body></html>");
|
|
|
|
ui->combo_hmd_model->setEnabled(false);
|
|
ui->combo_hmd_model->setCurrentIndex(-1);
|
|
ui->check_sideload->setEnabled(false);
|
|
}
|
|
else if (error != QNetworkReply::NetworkError::NoError)
|
|
{
|
|
throw std::runtime_error(apk_release_reply->errorString().toStdString());
|
|
}
|
|
else
|
|
{
|
|
auto json = nlohmann::json::parse(apk_release_reply->readAll());
|
|
|
|
for (auto & i: json["assets"])
|
|
{
|
|
std::string name = i["name"];
|
|
|
|
if (name.ends_with("-standard-release.apk"))
|
|
{
|
|
apk_url = i["browser_download_url"];
|
|
qDebug() << "Using APK URL" << apk_url.c_str();
|
|
break;
|
|
}
|
|
}
|
|
|
|
apk_downloaded = QFileInfo(apk_file).exists();
|
|
}
|
|
}
|
|
catch (std::exception & e)
|
|
{
|
|
qWarning() << "Cannot get APK information: " << e.what();
|
|
ui->label_release_info->setText(tr("Cannot get APK information: %1").arg(e.what()));
|
|
}
|
|
|
|
apk_release_reply->deleteLater();
|
|
apk_release_reply = nullptr;
|
|
update_welcome_page();
|
|
}
|
|
|
|
void wizard::update_welcome_page()
|
|
{
|
|
if (latest_release == "")
|
|
{
|
|
// We don't have the latest release information yet
|
|
ui->widget_store->setVisible(false);
|
|
ui->check_sideload->setVisible(false);
|
|
button(NextButton)->setEnabled(false);
|
|
}
|
|
|
|
auto devmode_url = ui->combo_hmd_model->currentData(role_devmode_url).toString();
|
|
auto store_name = ui->combo_hmd_model->currentData(role_store_name).toString();
|
|
auto store_url = ui->combo_hmd_model->currentData(role_store_url).toString();
|
|
|
|
ui->label_store_url->setText(QString(R"(<html><head/><body><p><a href="%1"><span style="text-decoration: underline; color:#2980b9;">%2</span></a></p></body></html>)").arg(store_url).arg(store_name));
|
|
ui->label_devmode_url->setText(QString(R"(<html><head/><body><p><a href="%1"><span style="text-decoration: underline; color:#2980b9;">%2</span></a></p></body></html>)").arg(devmode_url).arg(tr("How?")));
|
|
|
|
if (ui->combo_hmd_model->currentIndex() < 0)
|
|
{
|
|
// No headset selected
|
|
ui->widget_store->setVisible(false);
|
|
ui->check_sideload->setVisible(false);
|
|
button(NextButton)->setEnabled(false);
|
|
}
|
|
else if (store_name != "")
|
|
{
|
|
// Headset with a link to a store
|
|
ui->widget_store->setVisible(not ui->check_sideload->isChecked());
|
|
ui->check_sideload->setVisible(true);
|
|
button(NextButton)->setEnabled(apk_url != "" or nextId() != (int)wizard_page::sideload_download);
|
|
}
|
|
else
|
|
{
|
|
// Headset without store
|
|
ui->widget_store->setVisible(false);
|
|
ui->check_sideload->setVisible(false);
|
|
button(NextButton)->setEnabled(apk_url != "");
|
|
}
|
|
|
|
ui->label_devmode_url->setVisible(devmode_url != "");
|
|
|
|
if (nextId() == (int)wizard_page::sideload_download and ui->combo_hmd_model->currentIndex() >= 0 and apk_url != "")
|
|
button(NextButton)->setText(tr("Download"));
|
|
else
|
|
button(NextButton)->setText(QWizard::tr("&Next >", "do not translate, the QWizard translation will be used"));
|
|
}
|
|
|
|
void wizard::on_custom_button_clicked(int which)
|
|
{
|
|
switch ((wizard_page)currentId())
|
|
{
|
|
case wizard_page::select_headset_model:
|
|
if (which == QWizard::CustomButton1) // Download
|
|
next();
|
|
else if (which == QWizard::CustomButton2) // Skip
|
|
setCurrentId((int)wizard_page::connect_hmd);
|
|
return;
|
|
|
|
case wizard_page::sideload_download:
|
|
return;
|
|
|
|
case wizard_page::sideload_devmode:
|
|
return;
|
|
|
|
case wizard_page::sideload_install:
|
|
return;
|
|
|
|
case wizard_page::connect_hmd:
|
|
if (which == QWizard::CustomButton1) // Skip
|
|
next();
|
|
return;
|
|
|
|
case wizard_page::start_game:
|
|
return;
|
|
}
|
|
}
|
|
|
|
void wizard::on_page_changed(int id)
|
|
{
|
|
switch ((wizard_page)id)
|
|
{
|
|
case wizard_page::select_headset_model:
|
|
button(WizardButton::CustomButton1)->setText(tr("Download"));
|
|
button(WizardButton::CustomButton2)->setText(tr("Skip"));
|
|
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::NextButton, QWizard::CustomButton2, QWizard::CancelButton});
|
|
update_welcome_page();
|
|
return;
|
|
|
|
case wizard_page::sideload_download:
|
|
assert(not apk_downloaded);
|
|
start_download();
|
|
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::NextButton, QWizard::CancelButton});
|
|
button(BackButton)->setEnabled(false);
|
|
button(NextButton)->setEnabled(false);
|
|
return;
|
|
|
|
case wizard_page::sideload_devmode:
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::NextButton, QWizard::CancelButton});
|
|
button(NextButton)->setEnabled(false);
|
|
return;
|
|
|
|
case wizard_page::sideload_install:
|
|
start_install();
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::NextButton, QWizard::CancelButton});
|
|
button(BackButton)->setEnabled(false);
|
|
button(NextButton)->setEnabled(false);
|
|
return;
|
|
|
|
case wizard_page::connect_hmd:
|
|
button(WizardButton::CustomButton1)->setText(tr("Skip"));
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::NextButton, QWizard::CustomButton1, QWizard::CancelButton});
|
|
on_headset_connected_changed(server->isHeadsetConnected());
|
|
|
|
if (not server->isPairingEnabled())
|
|
server->enable_pairing(-1);
|
|
|
|
return;
|
|
|
|
case wizard_page::start_game:
|
|
setButtonLayout({QWizard::Stretch, QWizard::BackButton, QWizard::FinishButton, QWizard::CancelButton});
|
|
return;
|
|
}
|
|
}
|
|
|
|
void wizard::changeEvent(QEvent * e)
|
|
{
|
|
QWidget::changeEvent(e);
|
|
|
|
switch (e->type())
|
|
{
|
|
case QEvent::LanguageChange:
|
|
retranslate();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
int wizard::nextId() const
|
|
{
|
|
switch ((wizard_page)currentId())
|
|
{
|
|
case wizard_page::select_headset_model:
|
|
if (ui->combo_hmd_model->currentData(role_store_name).toString() != "" and not ui->check_sideload->isChecked())
|
|
return (int)wizard_page::connect_hmd;
|
|
else if (apk_downloaded)
|
|
return (int)wizard_page::sideload_devmode;
|
|
else
|
|
return (int)wizard_page::sideload_download;
|
|
|
|
case wizard_page::sideload_install:
|
|
return (int)wizard_page::connect_hmd;
|
|
|
|
default:
|
|
return QWizard::nextId();
|
|
}
|
|
}
|
|
|
|
void wizard::retranslate()
|
|
{
|
|
ui->retranslateUi(this);
|
|
ui->label_how_to_connect->setText(tr("Start the WiVRn app on your headset and connect to \"%1\".").arg(server->hostname()));
|
|
on_headset_connected_changed(server->isHeadsetConnected());
|
|
}
|
|
|
|
wizard::~wizard()
|
|
{
|
|
server->disable_pairing();
|
|
|
|
// android_devices_changed can be emitted when adb_service is destroyed, disconnect it before destroying
|
|
// the GUI
|
|
disconnect(&adb_service, &adb::android_devices_changed, this, &wizard::on_android_device_list_changed);
|
|
|
|
delete ui;
|
|
ui = nullptr;
|
|
}
|
|
|
|
void wizard::start_download()
|
|
{
|
|
ui->button_cancel_download->setEnabled(true);
|
|
|
|
QUrl url(apk_url.c_str());
|
|
|
|
qDebug() << "Downloading from" << url.toString();
|
|
|
|
auto apk_dir = std::filesystem::path(apk_file.fileName().toStdString()).parent_path();
|
|
std::filesystem::create_directories(apk_dir);
|
|
|
|
apk_file.open(QIODeviceBase::WriteOnly | QIODeviceBase::Truncate);
|
|
|
|
QNetworkRequest request(url);
|
|
|
|
if (apk_reply)
|
|
{
|
|
disconnect(apk_reply, &QNetworkReply::downloadProgress, this, &wizard::on_download_progress);
|
|
disconnect(apk_reply, &QNetworkReply::errorOccurred, this, &wizard::on_download_error);
|
|
disconnect(apk_reply, &QNetworkReply::finished, this, &wizard::on_download_finished);
|
|
apk_reply->abort();
|
|
apk_reply->deleteLater();
|
|
}
|
|
|
|
apk_reply = manager.get(request);
|
|
|
|
connect(apk_reply, &QNetworkReply::downloadProgress, this, &wizard::on_download_progress);
|
|
connect(apk_reply, &QNetworkReply::errorOccurred, this, &wizard::on_download_error);
|
|
connect(apk_reply, &QNetworkReply::finished, this, &wizard::on_download_finished);
|
|
|
|
ui->progress_download->setValue(0);
|
|
}
|
|
|
|
void wizard::cancel_download()
|
|
{
|
|
assert(apk_reply);
|
|
|
|
disconnect(apk_reply, &QNetworkReply::downloadProgress, this, &wizard::on_download_progress);
|
|
disconnect(apk_reply, &QNetworkReply::errorOccurred, this, &wizard::on_download_error);
|
|
disconnect(apk_reply, &QNetworkReply::finished, this, &wizard::on_download_finished);
|
|
apk_reply->abort();
|
|
apk_reply->deleteLater();
|
|
apk_reply = nullptr;
|
|
|
|
// Cancel and commit to close without saving the already written data, so that it can be reopened
|
|
apk_file.cancelWriting();
|
|
apk_file.commit();
|
|
|
|
back();
|
|
}
|
|
|
|
void wizard::on_download_progress(qint64 bytesReceived, qint64 bytesTotal)
|
|
{
|
|
assert(apk_reply);
|
|
|
|
if (not apk_reply->error())
|
|
{
|
|
if (bytesTotal > 0)
|
|
ui->progress_download->setValue(bytesReceived * 100 / bytesTotal);
|
|
|
|
apk_file.write(apk_reply->readAll());
|
|
}
|
|
}
|
|
|
|
void wizard::on_download_error(QNetworkReply::NetworkError code)
|
|
{
|
|
qDebug() << "Download error" << code;
|
|
|
|
// Cancel and commit to close without saving the already written data, so that it can be reopened
|
|
apk_file.cancelWriting();
|
|
apk_file.commit();
|
|
|
|
QMessageBox msgbox /*(this)*/;
|
|
msgbox.setIcon(QMessageBox::Critical);
|
|
msgbox.setText(tr("Error downloading the client:\n%1").arg(apk_reply->errorString()));
|
|
msgbox.setStandardButtons(QMessageBox::Retry | QMessageBox::Cancel);
|
|
|
|
#ifdef WORKAROUND_QTBUG_90005
|
|
setEnabled(false);
|
|
#endif
|
|
|
|
switch (msgbox.exec())
|
|
{
|
|
case QMessageBox::Retry:
|
|
start_download();
|
|
break;
|
|
|
|
case QMessageBox::Cancel:
|
|
back();
|
|
break;
|
|
}
|
|
|
|
#ifdef WORKAROUND_QTBUG_90005
|
|
setEnabled(true);
|
|
#endif
|
|
}
|
|
|
|
void wizard::on_download_finished()
|
|
{
|
|
assert(apk_reply);
|
|
|
|
if (not apk_reply->error())
|
|
{
|
|
auto last_modified = apk_reply->header(QNetworkRequest::LastModifiedHeader).value<QDateTime>();
|
|
apk_file.setFileTime(last_modified, QFileDevice::FileModificationTime);
|
|
|
|
apk_reply->deleteLater();
|
|
apk_reply = nullptr;
|
|
|
|
ui->button_cancel_download->setEnabled(false);
|
|
apk_file.commit();
|
|
apk_downloaded = true;
|
|
|
|
back(); // Remove current page from history before going to the install page
|
|
setCurrentId((int)wizard_page::sideload_devmode);
|
|
}
|
|
}
|
|
|
|
void wizard::on_android_device_list_changed(const std::vector<adb::device> & new_devs)
|
|
{
|
|
auto old_devs = std::move(android_devices);
|
|
android_devices = new_devs;
|
|
|
|
if (android_devices.empty())
|
|
ui->label_device_detected->setText(tr("No device detected."));
|
|
else
|
|
ui->label_device_detected->setText(tr("%n device(s) detected.", nullptr, android_devices.size()));
|
|
|
|
// Removed devices
|
|
for (int i = 0; i < ui->list_devices->count();)
|
|
{
|
|
QListWidgetItem * item = ui->list_devices->item(i);
|
|
|
|
std::string serial = item->data(QListWidgetItem::UserType).toString().toStdString();
|
|
|
|
if (std::ranges::none_of(android_devices, [&](const adb::device & x) { return x.serial() == serial; }))
|
|
delete item;
|
|
else
|
|
i++;
|
|
}
|
|
|
|
// Added devices
|
|
for (const auto & i: android_devices)
|
|
{
|
|
if (std::ranges::none_of(old_devs, [&](const adb::device & x) { return x == i; }))
|
|
{
|
|
auto it = i.properties().find("model");
|
|
|
|
const std::string model = (it == i.properties().end()) ? "Unknown model (" + i.serial() + ")" : it->second;
|
|
|
|
QListWidgetItem * item = new QListWidgetItem(QString::fromStdString(model));
|
|
|
|
item->setData(QListWidgetItem::UserType, QString::fromStdString(i.serial()));
|
|
|
|
ui->list_devices->addItem(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
void wizard::on_selected_android_device_changed()
|
|
{
|
|
if (ui->list_devices->currentItem())
|
|
button(NextButton)->setEnabled(true);
|
|
else
|
|
button(NextButton)->setEnabled(false);
|
|
}
|
|
|
|
void wizard::start_install()
|
|
{
|
|
QListWidgetItem * item = ui->list_devices->currentItem();
|
|
|
|
if (not item)
|
|
{
|
|
back();
|
|
return;
|
|
}
|
|
|
|
const std::string serial = item->data(QListWidgetItem::UserType).toString().toStdString();
|
|
|
|
for (adb::device & i: android_devices)
|
|
{
|
|
if (i.serial() == serial)
|
|
{
|
|
process_adb_install = i.install(apk_file.fileName().toStdString());
|
|
|
|
connect(process_adb_install.get(), &QProcess::finished, this, &wizard::on_install_finished);
|
|
connect(process_adb_install.get(), &QProcess::readyReadStandardOutput, this, &wizard::on_install_stdout);
|
|
connect(process_adb_install.get(), &QProcess::readyReadStandardError, this, &wizard::on_install_stderr);
|
|
process_adb_install->setParent(this);
|
|
process_adb_install->start();
|
|
ui->adb_install_logs->setPlainText("");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void wizard::on_install_stdout()
|
|
{
|
|
ui->adb_install_logs->appendPlainText(process_adb_install->readAllStandardOutput());
|
|
ui->adb_install_logs->verticalScrollBar()->setValue(ui->adb_install_logs->verticalScrollBar()->maximum());
|
|
}
|
|
|
|
void wizard::on_install_stderr()
|
|
{
|
|
ui->adb_install_logs->appendPlainText(process_adb_install->readAllStandardError());
|
|
ui->adb_install_logs->verticalScrollBar()->setValue(ui->adb_install_logs->verticalScrollBar()->maximum());
|
|
}
|
|
|
|
void wizard::on_install_finished(int exit_code, QProcess::ExitStatus exit_status)
|
|
{
|
|
if (exit_code == 0 and exit_status == QProcess::NormalExit)
|
|
{
|
|
// back(); // Remove current page from history before going to the connect page
|
|
// setCurrentId((int)wizard_page::connect_hmd);
|
|
|
|
button(NextButton)->setEnabled(true);
|
|
}
|
|
}
|
|
|
|
void wizard::on_headset_connected_changed(bool connected)
|
|
{
|
|
if (currentId() == (int)wizard_page::connect_hmd)
|
|
{
|
|
if (connected)
|
|
ui->label_client_status->setText(tr("The headset is connected."));
|
|
else
|
|
ui->label_client_status->setText(tr("The headset is not connected."));
|
|
|
|
button(NextButton)->setEnabled(connected);
|
|
ui->widget_troubleshoot->setHidden(connected);
|
|
}
|
|
}
|
|
|
|
void wizard::on_pin_changed(QString pin)
|
|
{
|
|
if (pin == "")
|
|
{
|
|
ui->label_pin_1->setVisible(false);
|
|
ui->label_pin_2->setVisible(false);
|
|
}
|
|
else
|
|
{
|
|
ui->label_pin_1->setVisible(true);
|
|
ui->label_pin_2->setVisible(true);
|
|
}
|
|
|
|
ui->label_pin_2->setText(pin);
|
|
}
|
|
|
|
#include "moc_wizard.cpp"
|