288 lines
11 KiB
C++
288 lines
11 KiB
C++
#include <QCoreApplication>
|
|
#include "ptt_hotkey_manager.h"
|
|
#include "radio_audio_engine.h"
|
|
#include "../db/db_manager.h"
|
|
#include "../../lib/debug_config.h"
|
|
|
|
#include <QApplication>
|
|
#include <QWidget>
|
|
#ifdef UTUN_PTT_PORTAL
|
|
#include "ptt_portal.h"
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
#include <qt_windows.h>
|
|
#elif defined(Q_OS_LINUX)
|
|
#include <X11/Xlib.h>
|
|
#include <X11/keysym.h>
|
|
#include <X11/XKBlib.h>
|
|
#endif
|
|
|
|
PttHotkeyManager* PttHotkeyManager::instance() {
|
|
static auto* manager = new PttHotkeyManager();
|
|
return manager;
|
|
}
|
|
|
|
PttHotkeyManager::PttHotkeyManager() : QObject(qApp) {
|
|
m_clock.start();
|
|
connect(RadioAudioEngine::instance(), &RadioAudioEngine::pttLatchChanged, this, [this]() { m_activation.reset(); });
|
|
connect(RadioAudioEngine::instance(), &RadioAudioEngine::stateChanged, this, [this]() {
|
|
auto* engine = RadioAudioEngine::instance();
|
|
if (!engine->isActive() || !engine->captureAvailable())
|
|
resetHotkey(engine->isActive() ? "microphone-unavailable" : "radio-stopped");
|
|
});
|
|
#ifdef Q_OS_LINUX
|
|
if (isSupported() && !usesPortal()) m_display = XOpenDisplay(nullptr);
|
|
if (isSupported() && !usesPortal() && !m_display) DEBUG_ERROR(DEBUG_CATEGORY_RADIO, "PTT: cannot open X11 display");
|
|
#endif
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (usesPortal()) {
|
|
m_portal = new PttPortal(this);
|
|
connect(m_portal, &PttPortal::talkingChanged, this, &PttHotkeyManager::updatePressed);
|
|
connect(m_portal, &PttPortal::resetRequested, this, [this](const QString& reason) {
|
|
resetHotkey(qPrintable(reason));
|
|
});
|
|
connect(m_portal, &PttPortal::descriptionsChanged, this, &PttHotkeyManager::portalChanged);
|
|
connect(m_portal, &PttPortal::statusChanged, this, &PttHotkeyManager::portalChanged);
|
|
}
|
|
#endif
|
|
m_timer.setInterval(10);
|
|
m_timer.setTimerType(Qt::PreciseTimer);
|
|
connect(&m_timer, &QTimer::timeout, this, &PttHotkeyManager::pollKeys);
|
|
}
|
|
|
|
PttHotkeyManager::~PttHotkeyManager() {
|
|
m_timer.stop();
|
|
#ifdef Q_OS_LINUX
|
|
if (m_display) XCloseDisplay(static_cast<Display*>(m_display));
|
|
#endif
|
|
}
|
|
|
|
bool PttHotkeyManager::isSupported() {
|
|
#ifdef Q_OS_WIN
|
|
return true;
|
|
#elif defined(Q_OS_LINUX)
|
|
return usesPortal() || QGuiApplication::platformName() == "xcb";
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void PttHotkeyManager::init(DbManager* db) {
|
|
m_db = db;
|
|
reload();
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (m_portal) { m_portal->initialize(); return; }
|
|
#endif
|
|
if (isSupported()) {
|
|
#ifdef Q_OS_LINUX
|
|
if (!m_display) return;
|
|
#endif
|
|
m_timer.start();
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: global keyboard polling enabled interval=10ms");
|
|
} else DEBUG_WARN(DEBUG_CATEGORY_RADIO, "PTT: global keyboard unavailable platform=%s", qPrintable(QGuiApplication::platformName()));
|
|
}
|
|
|
|
QString PttHotkeyManager::hotkey() const { return pttEncodeChord(m_chord); }
|
|
|
|
void PttHotkeyManager::setHotkey(const QString& value) {
|
|
if (usesPortal()) return;
|
|
resetHotkey("shortcut-configured");
|
|
m_chord = pttDecodeChord(value);
|
|
m_activation.pressed = pttChordHeld(m_chord, m_held);
|
|
if (!value.isEmpty() && m_chord.isEmpty()) DEBUG_WARN(DEBUG_CATEGORY_RADIO, "PTT: invalid key chord '%s'", qPrintable(value));
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: configured shortcut=[%s] codes=[%s]", qPrintable(describe(m_chord)), qPrintable(hotkey()));
|
|
}
|
|
|
|
void PttHotkeyManager::reload() {
|
|
setDoublePressEnabled(!m_db || !m_db->isOpen() || m_db->getUiState("radio_ptt_double_press") != "0");
|
|
setHotkey(m_db && m_db->isOpen() ? m_db->getUiState("radio_ptt_hotkey") : QString());
|
|
}
|
|
|
|
void PttHotkeyManager::setDoublePressEnabled(bool enabled) {
|
|
if (m_doublePressEnabled == enabled) return;
|
|
resetHotkey("double-press-setting-changed");
|
|
m_doublePressEnabled = enabled;
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: shortcut double-press locking enabled=%d", enabled);
|
|
}
|
|
|
|
/* Одинаковое поведение физического сочетания и Wayland-сигналов, без реакции на автоповтор. */
|
|
void PttHotkeyManager::updatePressed(bool pressed) {
|
|
auto* engine = RadioAudioEngine::instance();
|
|
if (m_capturing || !engine->isActive() || !engine->captureAvailable()) {
|
|
resetHotkey(m_capturing ? "recording" : engine->isActive() ? "microphone-unavailable" : "radio-stopped");
|
|
m_activation.pressed = pressed;
|
|
return;
|
|
}
|
|
if (m_activation.pressed == pressed) return;
|
|
bool doublePress = m_activation.observe(pressed, m_clock.elapsed(), m_doublePressEnabled ? QApplication::doubleClickInterval() : 0);
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_RADIO, "PTT: shortcut pressed=%d double_press=%d latched=%d group=%016llx",
|
|
pressed, doublePress, engine->pttLatched(), (unsigned long long)engine->groupId());
|
|
if (pressed && engine->pttLatched()) engine->setPttLatched(false, "shortcut-pressed");
|
|
else if (doublePress) engine->setPttLatched(true, "shortcut-double-press");
|
|
else engine->setHotkeyTalking(pressed);
|
|
}
|
|
|
|
/* Сброс не превращает ещё удерживаемую клавишу в новое нажатие после восстановления рации. */
|
|
void PttHotkeyManager::resetHotkey(const char* reason) {
|
|
if (m_activation.lastPress >= 0)
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: shortcut reset reason=%s pressed=%d double_press_pending=%d",
|
|
reason, m_activation.pressed, m_activation.lastPress >= 0);
|
|
m_activation.reset();
|
|
auto* engine = RadioAudioEngine::instance();
|
|
engine->setPttLatched(false, reason);
|
|
engine->setHotkeyTalking(false);
|
|
}
|
|
|
|
bool PttHotkeyManager::readKeys(PttKeyChord& held) const {
|
|
#ifdef Q_OS_WIN
|
|
for (int key = 8; key < 256; key++) {
|
|
// Общие VK_SHIFT/CONTROL/MENU дублируют левые/правые — исключаем их.
|
|
if (key == VK_SHIFT || key == VK_CONTROL || key == VK_MENU) continue;
|
|
if (GetAsyncKeyState(key) & 0x8000) held.insert(key);
|
|
}
|
|
return true;
|
|
#elif defined(Q_OS_LINUX)
|
|
if (!m_display) return false;
|
|
char keys[32];
|
|
if (!XQueryKeymap(static_cast<Display*>(m_display), keys)) return false;
|
|
for (int key = 8; key < 256; key++) if ((unsigned char)keys[key / 8] & (1u << (key % 8))) held.insert(key);
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void PttHotkeyManager::pollKeys() {
|
|
PttKeyChord held;
|
|
if (!readKeys(held)) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_RADIO, "PTT: keyboard query failed; transmission disabled");
|
|
m_timer.stop();
|
|
resetHotkey("keyboard-query-failed");
|
|
return;
|
|
}
|
|
if (m_capturing && !m_captureArmed && held.isEmpty()) {
|
|
m_captureArmed = true;
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: capture armed after all keys released");
|
|
}
|
|
bool changed = held != m_held;
|
|
m_held = held;
|
|
if (m_capturing && changed) {
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_RADIO, "PTT: capture poll armed=%d held=[%s] codes=[%s] application_state=%d",
|
|
m_captureArmed, qPrintable(describe(held)), qPrintable(pttEncodeChord(held)), int(QGuiApplication::applicationState()));
|
|
}
|
|
updatePressed(pttChordHeld(m_chord, held));
|
|
if (m_capturing && m_captureArmed && changed) emit keysChanged(held);
|
|
}
|
|
|
|
bool PttHotkeyManager::beginCapture() {
|
|
if (!m_timer.isActive() || m_capturing) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_RADIO, "PTT: capture unavailable polling=%d capturing=%d", m_timer.isActive(), m_capturing);
|
|
return false;
|
|
}
|
|
m_capturing = true;
|
|
PttKeyChord held;
|
|
if (!readKeys(held)) {
|
|
m_capturing = false;
|
|
DEBUG_ERROR(DEBUG_CATEGORY_RADIO, "PTT: cannot read keys when starting capture");
|
|
return false;
|
|
}
|
|
m_captureArmed = held.isEmpty(); // ждём отпускания клавиши, которой нажали кнопку
|
|
resetHotkey("recording-started");
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: capture started armed=%d held=[%s] codes=[%s] platform=%s interval=%dms",
|
|
m_captureArmed, qPrintable(describe(held)), qPrintable(pttEncodeChord(held)),
|
|
qPrintable(QGuiApplication::platformName()), m_timer.interval());
|
|
if (!m_captureArmed) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: capture waiting for ALL keys to be released; keys pressed meanwhile are ignored");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PttHotkeyManager::endCapture() {
|
|
if (!m_capturing) return;
|
|
m_capturing = false;
|
|
DEBUG_INFO(DEBUG_CATEGORY_RADIO, "PTT: capture finished armed=%d polling=%d last_held=[%s] codes=[%s]",
|
|
m_captureArmed, m_timer.isActive(), qPrintable(describe(m_held)), qPrintable(pttEncodeChord(m_held)));
|
|
}
|
|
|
|
QString PttHotkeyManager::keyName(int key) const {
|
|
#ifdef Q_OS_WIN
|
|
switch (key) {
|
|
case VK_LSHIFT: return "ShiftL"; case VK_RSHIFT: return "ShiftR";
|
|
case VK_LCONTROL: return "CtrlL"; case VK_RCONTROL: return "CtrlR";
|
|
case VK_LMENU: return "AltL"; case VK_RMENU: return "AltR";
|
|
case VK_LWIN: return "WinL"; case VK_RWIN: return "WinR";
|
|
}
|
|
UINT scan = MapVirtualKeyW(key, MAPVK_VK_TO_VSC_EX);
|
|
LONG param = LONG((scan & 0xff) << 16);
|
|
if (scan & 0xff00) param |= 1 << 24;
|
|
wchar_t name[128];
|
|
if (GetKeyNameTextW(param, name, 128)) return QString::fromWCharArray(name);
|
|
#elif defined(Q_OS_LINUX)
|
|
if (m_display) {
|
|
KeySym sym = XkbKeycodeToKeysym(static_cast<Display*>(m_display), key, 0, 0);
|
|
switch (sym) {
|
|
case XK_Shift_L: return "ShiftL"; case XK_Shift_R: return "ShiftR";
|
|
case XK_Control_L: return "CtrlL"; case XK_Control_R: return "CtrlR";
|
|
case XK_Alt_L: return "AltL"; case XK_Alt_R: return "AltR";
|
|
case XK_Super_L: return "WinL"; case XK_Super_R: return "WinR";
|
|
case XK_space: return "Space";
|
|
}
|
|
const char* name = XKeysymToString(sym);
|
|
if (name) return QString::fromLatin1(name);
|
|
}
|
|
#endif
|
|
return QCoreApplication::translate("ChatGui", "Key %1").arg(key);
|
|
}
|
|
|
|
QString PttHotkeyManager::describe(const PttKeyChord& chord) const {
|
|
auto keys = chord.values();
|
|
std::sort(keys.begin(), keys.end());
|
|
QStringList names;
|
|
for (int key : keys) names << keyName(key);
|
|
return names.isEmpty() ? QCoreApplication::translate("ChatGui", "Not set") : names.join(" + ");
|
|
}
|
|
|
|
bool PttHotkeyManager::usesPortal() {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
return qEnvironmentVariable("XDG_SESSION_TYPE") == "wayland" || QGuiApplication::platformName().startsWith("wayland");
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
void PttHotkeyManager::configurePortal(QWidget* parentWindow) {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (!m_portal) return;
|
|
QString id;
|
|
if (parentWindow && QGuiApplication::platformName() == "xcb")
|
|
id = "x11:" + QString::number(qulonglong(parentWindow->window()->winId()), 16);
|
|
m_portal->configure(id);
|
|
#else
|
|
Q_UNUSED(parentWindow);
|
|
#endif
|
|
}
|
|
QString PttHotkeyManager::portalDescription() const {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (m_portal) return m_portal->description();
|
|
#endif
|
|
return {};
|
|
}
|
|
QString PttHotkeyManager::portalStatus() const {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (m_portal) return m_portal->status();
|
|
#endif
|
|
return {};
|
|
}
|
|
bool PttHotkeyManager::portalBusy() const {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (m_portal) return m_portal->busy();
|
|
#endif
|
|
return false;
|
|
}
|
|
void PttHotkeyManager::inhibitPortal(bool inhibited) {
|
|
#ifdef UTUN_PTT_PORTAL
|
|
if (m_portal) m_portal->setInhibited(inhibited);
|
|
#else
|
|
Q_UNUSED(inhibited);
|
|
#endif
|
|
}
|