227 lines
14 KiB
C++
227 lines
14 KiB
C++
#include <QCoreApplication>
|
|
#include <algorithm>
|
|
#include "devgroupdialog.h"
|
|
#include "../transport/gui_bridge.h"
|
|
#include "debug_ui.h"
|
|
#include <QDialog>
|
|
#include <QVBoxLayout>
|
|
#include <QLabel>
|
|
#include <QPushButton>
|
|
#include <QLineEdit>
|
|
#include <QListWidget>
|
|
#include <QInputDialog>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QTimer>
|
|
#include <QPointer>
|
|
#include <QHash>
|
|
#include <QSet>
|
|
#include <QDialogButtonBox>
|
|
#include <QRegularExpressionValidator>
|
|
extern "C" {
|
|
#include "../../../src/chat/chat_devgroup.h"
|
|
#include "../../../lib/mem.h"
|
|
}
|
|
class DevgroupDialog;
|
|
static QPointer<DevgroupDialog> active;
|
|
static QList<QPointer<QPushButton>> buttons;
|
|
static quint64 nextRequest = 0;
|
|
static QPointer<QWidget> invitationWindow;
|
|
static quint64 statusRequest = 0, lastAutomaticSnapshot = 0;
|
|
static QHash<quint64, QString> acceptRequests;
|
|
static QHash<QString, QPointer<QInputDialog>> pinDialogs;
|
|
static QSet<QString> dismissedInvites, awaitingPins, attemptedPins;
|
|
static void refreshInvitations();
|
|
static void automaticInvitations(const QJsonObject& snapshot);
|
|
static void devgroupResult(const uint8_t* data, int len);
|
|
class DevgroupDialog : public QDialog {
|
|
public:
|
|
static QString tr(const char* text) { return QCoreApplication::translate("DevgroupDialog", text); }
|
|
void refresh() { send(CHAT_DEVGROUP_STATUS); }
|
|
DevgroupDialog(QWidget* parent, const QString& channel, quint64 peer, bool inviting = false) : QDialog(parent), channel(channel), peer(peer), inviting(inviting) {
|
|
setAttribute(Qt::WA_DeleteOnClose); setModal(inviting); setWindowTitle(inviting ? tr("Add my device") : tr("My devices")); resize(480, 360);
|
|
auto* layout = new QVBoxLayout(this);
|
|
title = new QLabel(this); layout->addWidget(title);
|
|
name = new QLineEdit(this); name->setPlaceholderText(tr("Device group name")); layout->addWidget(name);
|
|
auto* rename = new QPushButton(tr("Create / rename"), this); layout->addWidget(rename);
|
|
connect(rename, &QPushButton::clicked, this, [this] { send(CHAT_DEVGROUP_RENAME, name->text()); });
|
|
if (peer && !inviting) {
|
|
auto* invite = new QPushButton(tr("Add device %1").arg(QString::number(peer, 16)), this); layout->addWidget(invite);
|
|
connect(invite, &QPushButton::clicked, this, [this] { send(CHAT_DEVGROUP_INVITE); });
|
|
}
|
|
status = new QLabel(this); status->setWordWrap(true); status->setTextInteractionFlags(Qt::TextSelectableByMouse); layout->addWidget(status);
|
|
list = new QListWidget(this); layout->addWidget(list);
|
|
auto* accept = new QPushButton(tr("Enter PIN for selected invitation"), this); layout->addWidget(accept);
|
|
connect(accept, &QPushButton::clicked, this, [this] {
|
|
const auto* item = list->currentItem(); if (!item || item->data(Qt::UserRole).toString().isEmpty()) return;
|
|
const QString id = item->data(Qt::UserRole).toString(); bool ok = false;
|
|
const QString pin = QInputDialog::getText(this, tr("Add device"), tr("PIN shown on the inviting device"), QLineEdit::Normal, {}, &ok);
|
|
if (ok) send(CHAT_DEVGROUP_ACCEPT, id, pin);
|
|
});
|
|
auto* leave = new QPushButton(tr("Leave device group"), this); layout->addWidget(leave);
|
|
connect(leave, &QPushButton::clicked, this, [this] { send(CHAT_DEVGROUP_LEAVE); });
|
|
auto* timer = new QTimer(this); timer->setInterval(1000);
|
|
connect(timer, &QTimer::timeout, this, [this] { if (!gui_bridge_is_uasync_ready()) pending.clear();
|
|
else if (!pending.values().contains(CHAT_DEVGROUP_STATUS)) send(CHAT_DEVGROUP_STATUS); });
|
|
if (inviting) {
|
|
title->hide(); name->hide(); rename->hide(); list->hide(); accept->hide(); leave->hide();
|
|
}
|
|
timer->start(); send(inviting ? CHAT_DEVGROUP_INVITE : CHAT_DEVGROUP_STATUS);
|
|
}
|
|
void result(const uint8_t* data, int len) {
|
|
if (len < 9) return;
|
|
quint64 id = 0; for (int i = 0; i < 8; ++i) id |= quint64(data[i]) << (8*i);
|
|
if (!pending.contains(id)) return;
|
|
const int action = pending.take(id);
|
|
if (!data[8]) { status->setText(tr("Operation failed. Check connection and invitation status.")); return; }
|
|
const auto json = QJsonDocument::fromJson(QByteArray(reinterpret_cast<const char*>(data+9), len-9)).object();
|
|
if (action == CHAT_DEVGROUP_INVITE) {
|
|
outgoingId = json["id"].toString(); pinText = tr("PIN: %1 — enter it on the other device within 2 minutes.").arg(json["pin"].toString());
|
|
status->setText(pinText); return;
|
|
}
|
|
title->setText(json["group"].toString().isEmpty() ? tr("No device group") : json["name"].toString());
|
|
const QString selected = list->currentItem() ? list->currentItem()->data(Qt::UserRole).toString() : QString();
|
|
list->clear();
|
|
const QStringList states = {{}, tr("Waiting for PIN"), tr("Checking PIN"), tr("Transferring keys"), tr("Joined"),
|
|
tr("Rejected"), tr("Expired"), tr("Result unknown")};
|
|
for (const auto value : json["invitations"].toArray()) {
|
|
const auto invitation = value.toObject(); const int state = invitation["state"].toInt();
|
|
if (inviting && invitation["id"].toString() == outgoingId) {
|
|
status->setText((state < 4 ? pinText + "\n" : QString()) + states.value(state));
|
|
}
|
|
auto* item = new QListWidgetItem(invitation["peer"].toString() + " — " + states.value(state), list);
|
|
if (!invitation["outgoing"].toInt() && state == 1) {
|
|
item->setData(Qt::UserRole, invitation["id"].toString());
|
|
if (item->data(Qt::UserRole).toString() == selected) list->setCurrentItem(item);
|
|
}
|
|
}
|
|
}
|
|
private:
|
|
void send(chat_devgroup_action action, const QString& text = {}, const QString& pin = {}) {
|
|
const auto bytes = text.toUtf8(), code = pin.toUtf8();
|
|
if (bytes.size() >= 128 || bytes.contains('\0') || code.size() >= 5 || code.contains('\0')) {
|
|
status->setText(tr("Invalid name or PIN")); return;
|
|
}
|
|
auto* req = static_cast<chat_devgroup_request*>(u_calloc(1, sizeof(chat_devgroup_request)));
|
|
if (!req) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT, "devgroup UI: allocation failed"); return; }
|
|
req->inst = gui_bridge_get_inst(); req->request_id = ++nextRequest; req->group = channel.toULongLong(); req->peer = peer;
|
|
req->action = action; memcpy(req->text, bytes.constData(), bytes.size()); memcpy(req->pin, code.constData(), code.size());
|
|
const quint64 id = req->request_id;
|
|
if (gui_bridge_post_uasync_owned_fn(chat_devgroup_trampoline, req) < 0) {
|
|
memset(req, 0, sizeof(*req)); u_free(req); status->setText(tr("Core unavailable"));
|
|
DEBUG_WARN(DEBUG_CATEGORY_CHAT, "devgroup UI: core unavailable"); return;
|
|
}
|
|
pending.insert(id, action);
|
|
}
|
|
QString channel, outgoingId, pinText; quint64 peer; bool inviting;
|
|
QLabel *title, *status; QLineEdit* name; QListWidget* list;
|
|
QHash<quint64, int> pending;
|
|
};
|
|
static void devgroupResult(const uint8_t* data, int len) {
|
|
if (!len) {
|
|
refreshInvitations();
|
|
for (const auto& button : buttons) if (button) button->setText(QCoreApplication::translate("AccountList", "My devices") + " •");
|
|
if (active) active->refresh();
|
|
} else {
|
|
if (len >= 9) {
|
|
quint64 id = 0; for (int i = 0; i < 8; ++i) id |= quint64(data[i]) << (8*i);
|
|
const bool automatic = id == statusRequest || acceptRequests.contains(id);
|
|
if (id == statusRequest) statusRequest = 0;
|
|
if (acceptRequests.contains(id)) awaitingPins.remove(acceptRequests.take(id));
|
|
if (automatic) {
|
|
if (data[8] && id >= lastAutomaticSnapshot) {
|
|
lastAutomaticSnapshot = id;
|
|
automaticInvitations(QJsonDocument::fromJson(QByteArray(reinterpret_cast<const char*>(data+9), len-9)).object());
|
|
}
|
|
else if (!data[8]) DEBUG_WARN(DEBUG_CATEGORY_CHAT, "devgroup UI: automatic PIN/status request refused");
|
|
}
|
|
}
|
|
if (active) active->result(data, len);
|
|
}
|
|
}
|
|
void watchDevgroupButton(QPushButton* button) {
|
|
buttons.erase(std::remove_if(buttons.begin(), buttons.end(), [](const QPointer<QPushButton>& b) { return b.isNull(); }), buttons.end());
|
|
buttons.append(button); gui_bridge_set_devgroup_result_cb(devgroupResult);
|
|
}
|
|
void showDevgroupDialog(QWidget* parent, const QString& channel, quint64 peer) {
|
|
if (active) { active->close(); active = nullptr; }
|
|
gui_bridge_set_devgroup_result_cb(devgroupResult);
|
|
active = new DevgroupDialog(parent, channel, peer); active->show();
|
|
}
|
|
|
|
static void refreshInvitations() {
|
|
if (!invitationWindow || statusRequest || !gui_bridge_is_uasync_ready()) return;
|
|
auto* req = static_cast<chat_devgroup_request*>(u_calloc(1, sizeof(chat_devgroup_request)));
|
|
if (!req) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT, "devgroup UI: status allocation failed"); return; }
|
|
req->inst = gui_bridge_get_inst(); req->action = CHAT_DEVGROUP_STATUS; req->request_id = ++nextRequest;
|
|
const quint64 id = req->request_id;
|
|
if (gui_bridge_post_uasync_owned_fn(chat_devgroup_trampoline, req) < 0) {
|
|
u_free(req); DEBUG_WARN(DEBUG_CATEGORY_CHAT, "devgroup UI: status enqueue failed"); return;
|
|
}
|
|
statusRequest = id;
|
|
}
|
|
static void automaticInvitations(const QJsonObject& snapshot) {
|
|
if (!invitationWindow) return;
|
|
QSet<QString> waiting;
|
|
for (const auto value : snapshot["invitations"].toArray()) {
|
|
const auto entry = value.toObject(); const QString id = entry["id"].toString();
|
|
if (entry["outgoing"].toInt() || entry["state"].toInt() != 1) continue;
|
|
waiting.insert(id);
|
|
if (pinDialogs.value(id) || dismissedInvites.contains(id) || awaitingPins.contains(id)) continue;
|
|
auto* dialog = new QInputDialog(invitationWindow); pinDialogs.insert(id, dialog);
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose); dialog->setObjectName("devgroupIncomingPin");
|
|
dialog->setWindowTitle(DevgroupDialog::tr("Add my device"));
|
|
dialog->setLabelText(entry["peer"].toString() + "\n" + DevgroupDialog::tr(attemptedPins.contains(id) ?
|
|
"PIN was not accepted. Try again." : "PIN shown on the inviting device"));
|
|
dialog->setInputMode(QInputDialog::TextInput); dialog->setWindowModality(Qt::ApplicationModal);
|
|
if (auto* edit = dialog->findChild<QLineEdit*>()) {
|
|
edit->setMaxLength(4); edit->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9]{0,4}"), edit));
|
|
}
|
|
QObject::connect(dialog, &QInputDialog::textValueChanged, dialog, [dialog](const QString& text) {
|
|
if (auto* box = dialog->findChild<QDialogButtonBox*>()) box->button(QDialogButtonBox::Ok)->setEnabled(text.size() == 4);
|
|
});
|
|
QObject::connect(dialog, &QDialog::finished, dialog, [dialog, id](int result) {
|
|
pinDialogs.remove(id);
|
|
if (result != QDialog::Accepted) { dismissedInvites.insert(id); return; }
|
|
auto* req = static_cast<chat_devgroup_request*>(u_calloc(1, sizeof(chat_devgroup_request)));
|
|
if (!req) { DEBUG_ERROR(DEBUG_CATEGORY_CHAT, "devgroup UI: PIN request allocation failed"); return; }
|
|
const auto pin = dialog->textValue().toLatin1(), invite = id.toLatin1();
|
|
if (pin.size() != 4 || invite.size() != 32) { u_free(req); DEBUG_WARN(DEBUG_CATEGORY_CHAT, "devgroup UI: invalid PIN request"); return; }
|
|
req->inst = gui_bridge_get_inst(); req->action = CHAT_DEVGROUP_ACCEPT; req->request_id = ++nextRequest;
|
|
memcpy(req->text, invite.constData(), 32); memcpy(req->pin, pin.constData(), 4);
|
|
const quint64 request = req->request_id;
|
|
if (gui_bridge_post_uasync_owned_fn(chat_devgroup_trampoline, req) < 0) {
|
|
memset(req, 0, sizeof(*req)); u_free(req); DEBUG_WARN(DEBUG_CATEGORY_CHAT, "devgroup UI: PIN enqueue failed"); return;
|
|
}
|
|
awaitingPins.insert(id); attemptedPins.insert(id); acceptRequests.insert(request, id);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CHAT, "devgroup UI: PIN submitted invite=%s", qPrintable(id));
|
|
});
|
|
dialog->open();
|
|
if (auto* box = dialog->findChild<QDialogButtonBox*>()) box->button(QDialogButtonBox::Ok)->setEnabled(false);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CHAT, "devgroup UI: incoming PIN dialog opened invite=%s", qPrintable(id));
|
|
}
|
|
for (const auto& id : pinDialogs.keys()) if (!waiting.contains(id)) {
|
|
auto dialog = pinDialogs.take(id); if (dialog) { dialog->disconnect(); dialog->close(); }
|
|
}
|
|
}
|
|
void initDevgroupUi(QWidget* window) {
|
|
if (invitationWindow) return;
|
|
statusRequest = 0; lastAutomaticSnapshot = 0; acceptRequests.clear(); dismissedInvites.clear(); awaitingPins.clear(); attemptedPins.clear();
|
|
invitationWindow = window; gui_bridge_set_devgroup_result_cb(devgroupResult);
|
|
auto* timer = new QTimer(window); timer->setInterval(1000);
|
|
QObject::connect(timer, &QTimer::timeout, window, [] {
|
|
if (!gui_bridge_is_uasync_ready()) {
|
|
statusRequest = 0; lastAutomaticSnapshot = 0; acceptRequests.clear(); awaitingPins.clear(); attemptedPins.clear(); dismissedInvites.clear();
|
|
automaticInvitations(QJsonObject{{"invitations", QJsonArray{}}}); return;
|
|
}
|
|
refreshInvitations();
|
|
});
|
|
timer->start(); refreshInvitations();
|
|
}
|
|
void inviteMyDevice(QWidget* parent, const QString& channel, quint64 peer) {
|
|
if (active) { active->close(); active = nullptr; }
|
|
gui_bridge_set_devgroup_result_cb(devgroupResult);
|
|
active = new DevgroupDialog(parent, channel, peer, true); active->show();
|
|
}
|