fixed open Qr QML & add check error code & add test

client/ui/controllers/api/pairingUiController.cpp

@@ -1,7 +1,13 @@
 #include "pairingUiController.h"
 
+#include <QRegularExpression>
+#include <QTimer>
 #include <QUuid>
 
+#if defined(Q_OS_ANDROID)
+    #include "platforms/android/android_controller.h"
+#endif
+
 #include "core/controllers/gatewayController.h"
 #include "core/models/serverConfig.h"
 #include "core/models/api/apiV2ServerConfig.h"
@@ -14,8 +20,33 @@ namespace
 {
 constexpr auto kGenerateQrPath = "%1api/v1/generate_qr";
 constexpr auto kScanQrPath = "%1api/v1/scan_qr";
+constexpr int kPairingRetryMaxAttempts = 3;
+
+bool isPairingRetriableError(ErrorCode code)
+{
+    switch (code) {
+    case ErrorCode::ApiPairingRateLimitedError:
+    case ErrorCode::ApiPairingServiceUnavailableError:
+    case ErrorCode::ApiConfigDownloadError:
+        return true;
+    default:
+        return false;
+    }
 }
 
+int pairingRetryDelayMs(int zeroBasedAttempt)
+{
+    constexpr int baseMs = 500;
+    return baseMs * (1 << zeroBasedAttempt);
+}
+} // namespace
+
+#if defined(Q_OS_ANDROID)
+namespace {
+PairingUiController *g_pairingUiForAndroidQr = nullptr;
+}
+#endif
+
 PairingUiController::PairingUiController(PairingController *pairingController, ServersController *serversController,
                                          SubscriptionController *subscriptionController,
                                          SecureAppSettingsRepository *appSettingsRepository, QObject *parent)
@@ -25,8 +56,63 @@ PairingUiController::PairingUiController(PairingController *pairingController, S
       m_subscriptionController(subscriptionController),
       m_appSettingsRepository(appSettingsRepository)
 {
+#if defined(Q_OS_ANDROID)
+    g_pairingUiForAndroidQr = this;
+#endif
 }
 
+PairingUiController::~PairingUiController()
+{
+#if defined(Q_OS_ANDROID)
+    if (g_pairingUiForAndroidQr == this) {
+        g_pairingUiForAndroidQr = nullptr;
+    }
+#endif
+}
+
+void PairingUiController::setTvPairingUiPhase(int phase)
+{
+    if (m_tvPairingUiPhase == phase) {
+        return;
+    }
+    m_tvPairingUiPhase = phase;
+    emit tvPairingUiPhaseChanged();
+}
+
+void PairingUiController::openPairingQrScanner()
+{
+#if defined(Q_OS_ANDROID)
+    AndroidController::instance()->startQrReaderActivity();
+#endif
+}
+
+bool PairingUiController::applyScannedTextAsPairingUuid(const QString &raw)
+{
+    const QString t = raw.trimmed();
+    if (t.startsWith(QStringLiteral("vpn://"), Qt::CaseInsensitive)) {
+        return false;
+    }
+    static const QRegularExpression re(QStringLiteral(
+            "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}"));
+    const QRegularExpressionMatch m = re.match(t);
+    if (!m.hasMatch()) {
+        return false;
+    }
+    const QString uuid = m.captured(0);
+    emit pairingUuidFromScan(uuid);
+    return true;
+}
+
+#if defined(Q_OS_ANDROID)
+bool PairingUiController::tryConsumeAndroidQrScan(const QString &code)
+{
+    if (!g_pairingUiForAndroidQr) {
+        return false;
+    }
+    return g_pairingUiForAndroidQr->applyScannedTextAsPairingUuid(code);
+}
+#endif
+
 QVariantList PairingUiController::tvQrCodes() const
 {
     QVariantList list;
@@ -93,6 +179,18 @@ void PairingUiController::resetTvQrDisplay()
     emit tvSessionUuidChanged();
 }
 
+QString PairingUiController::tvFailureMessage(ErrorCode code) const
+{
+    switch (code) {
+    case ErrorCode::ApiConfigTimeoutError:
+        return tr("QR session expired. Tap Start to show a new QR code.");
+    case ErrorCode::ApiConfigAlreadyAdded:
+        return tr("This configuration is already on the device.");
+    default:
+        return tr("Pairing failed");
+    }
+}
+
 void PairingUiController::startTvQrSession()
 {
     if (!m_pairingController || !m_appSettingsRepository) {
@@ -108,6 +206,9 @@ void PairingUiController::startTvQrSession()
         m_tvWatcher.clear();
     }
 
+    ++m_tvSessionGeneration;
+    const quint64 generation = m_tvSessionGeneration;
+
     m_tvSessionUuid = QUuid::createUuid().toString(QUuid::WithoutBraces);
     const QByteArray qrPayload = m_tvSessionUuid.toUtf8();
     m_tvQrCodes = qrCodeUtils::generateQrCodeImageSeries(qrPayload);
@@ -118,6 +219,19 @@ void PairingUiController::startTvQrSession()
     emit tvStatusMessageChanged();
 
     setTvBusy(true);
+    setTvPairingUiPhase(1);
+
+    dispatchTvGenerateQrAttempt(generation, 0);
+}
+
+void PairingUiController::dispatchTvGenerateQrAttempt(quint64 generation, int retryAttempt)
+{
+    if (!m_pairingController || !m_appSettingsRepository) {
+        return;
+    }
+    if (generation != m_tvSessionGeneration) {
+        return;
+    }
 
     const bool isTestPurchase = false;
     auto gatewayController = QSharedPointer<GatewayController>::create(m_appSettingsRepository->getGatewayEndpoint(isTestPurchase),
@@ -126,12 +240,15 @@ void PairingUiController::startTvQrSession()
                                                                        m_appSettingsRepository->isStrictKillSwitchEnabled());
 
     const QJsonObject payload = m_pairingController->buildGenerateQrPayload(m_tvSessionUuid);
-    const QFuture<QPair<ErrorCode, QByteArray>> future = gatewayController->postAsync(QString::fromLatin1(kGenerateQrPath), payload);
+    QNetworkReply *replyRaw = nullptr;
+    const QFuture<QPair<ErrorCode, QByteArray>> future =
+            gatewayController->postAsync(QString::fromLatin1(kGenerateQrPath), payload, &replyRaw);
+    m_tvNetworkReply = replyRaw;
 
     auto *watcher = new QFutureWatcher<QPair<ErrorCode, QByteArray>>(this);
     m_tvWatcher = watcher;
     QObject::connect(watcher, &QFutureWatcher<QPair<ErrorCode, QByteArray>>::finished, this,
-                     [this, gatewayController, watcher]() {
+                     [this, gatewayController, watcher, generation, retryAttempt]() {
                          Q_UNUSED(gatewayController);
                          const auto result = watcher->result();
                          watcher->deleteLater();
@@ -139,33 +256,67 @@ void PairingUiController::startTvQrSession()
                              m_tvWatcher.clear();
                          }
 
-                         setTvBusy(false);
-
-                         if (result.first != ErrorCode::NoError) {
-                             m_tvStatusMessage = tr("Pairing failed");
-                             emit tvStatusMessageChanged();
-                             emit errorOccurred(result.first);
+                         if (generation != m_tvSessionGeneration) {
                              return;
                          }
 
+                         m_tvNetworkReply.clear();
+
                          PairingController::QrPairingConfigPayload out;
-                         const ErrorCode parseErr = PairingController::parseGenerateQrResponseBody(result.second, out);
-                         if (parseErr != ErrorCode::NoError) {
-                             m_tvStatusMessage = tr("Pairing failed");
+                         ErrorCode logicalErr = result.first;
+                         if (logicalErr == ErrorCode::NoError) {
+                             logicalErr = PairingController::parseGenerateQrResponseBody(result.second, out);
+                         }
+
+                         if (logicalErr == ErrorCode::NoError) {
+                             ServerConfig importedConfig;
+                             const ErrorCode impErr = m_subscriptionController->importServerFromQrPairingResponse(
+                                     out.config, out.serviceInfo, out.supportedProtocols, importedConfig);
+                             Q_UNUSED(importedConfig);
+                             setTvBusy(false);
+                             if (impErr != ErrorCode::NoError) {
+                                 setTvPairingUiPhase(2);
+                                 m_tvStatusMessage = tvFailureMessage(impErr);
+                                 emit tvStatusMessageChanged();
+                                 emit errorOccurred(impErr);
+                                 resetTvQrDisplay();
+                                 return;
+                             }
+                             resetTvQrDisplay();
+                             m_tvStatusMessage = tr("Configuration received");
                              emit tvStatusMessageChanged();
-                             emit errorOccurred(parseErr);
+                             emit tvPairingConfigReceived();
+                             setTvPairingUiPhase(0);
                              return;
                          }
 
-                         m_tvStatusMessage = tr("Configuration received");
+                         if (isPairingRetriableError(logicalErr) && retryAttempt + 1 < kPairingRetryMaxAttempts) {
+                             const int delayMs = pairingRetryDelayMs(retryAttempt);
+                             QTimer::singleShot(delayMs, this, [this, generation, retryAttempt]() {
+                                 if (generation != m_tvSessionGeneration) {
+                                     return;
+                                 }
+                                 dispatchTvGenerateQrAttempt(generation, retryAttempt + 1);
+                             });
+                             return;
+                         }
+
+                         setTvBusy(false);
+                         setTvPairingUiPhase(logicalErr == ErrorCode::ApiConfigTimeoutError ? 3 : 2);
+                         m_tvStatusMessage = tvFailureMessage(logicalErr);
                          emit tvStatusMessageChanged();
-                         emit tvPairingConfigReceived();
+                         emit errorOccurred(logicalErr);
                      });
     watcher->setFuture(future);
 }
 
 void PairingUiController::cancelTvQrSession()
 {
+    ++m_tvSessionGeneration;
+    if (m_tvNetworkReply) {
+        m_tvNetworkReply->abort();
+    }
+    m_tvNetworkReply.clear();
     if (m_tvWatcher) {
         m_tvWatcher->disconnect();
         m_tvWatcher->deleteLater();
@@ -175,6 +326,26 @@ void PairingUiController::cancelTvQrSession()
     m_tvStatusMessage.clear();
     emit tvStatusMessageChanged();
     resetTvQrDisplay();
+    setTvPairingUiPhase(0);
+}
+
+void PairingUiController::cancelAllPairingActivity()
+{
+    ++m_phoneSessionGeneration;
+    if (m_phoneNetworkReply) {
+        m_phoneNetworkReply->abort();
+    }
+    m_phoneNetworkReply.clear();
+    if (m_phoneWatcher) {
+        m_phoneWatcher->disconnect();
+        m_phoneWatcher->deleteLater();
+        m_phoneWatcher.clear();
+    }
+    setPhoneBusy(false);
+    m_phoneStatusMessage.clear();
+    emit phoneStatusMessageChanged();
+
+    cancelTvQrSession();
 }
 
 void PairingUiController::submitPhonePairing(const QString &qrUuid, int serverIndex)
@@ -224,29 +395,50 @@ void PairingUiController::submitPhonePairing(const QString &qrUuid, int serverIn
         return;
     }
 
+    const ErrorCode fieldErr = PairingController::validatePairingScanFields(trimmedUuid, vpnKey, apiKey);
+    if (fieldErr != ErrorCode::NoError) {
+        emit errorOccurred(fieldErr);
+        return;
+    }
+
+    ++m_phoneSessionGeneration;
+    const quint64 phoneGeneration = m_phoneSessionGeneration;
+
     m_phoneStatusMessage = tr("Sending…");
     emit phoneStatusMessageChanged();
     setPhoneBusy(true);
 
-    runPhonePairingRequest(trimmedUuid, apiV2->apiConfig.isTestPurchase, vpnKey, serviceInfo, supportedProtocols, apiKey);
+    dispatchPhoneScanQrAttempt(trimmedUuid, apiV2->apiConfig.isTestPurchase, vpnKey, serviceInfo, supportedProtocols, apiKey,
+                               phoneGeneration, 0);
 }
 
-void PairingUiController::runPhonePairingRequest(const QString &qrUuid, const bool isTestPurchase, const QString &vpnKey,
-                                                 const QJsonObject &serviceInfo, const QJsonArray &supportedProtocols,
-                                                 const QString &apiKey)
+void PairingUiController::dispatchPhoneScanQrAttempt(const QString &qrUuid, const bool isTestPurchase, const QString &vpnKey,
+                                                     const QJsonObject &serviceInfo, const QJsonArray &supportedProtocols,
+                                                     const QString &apiKey, quint64 generation, int retryAttempt)
 {
+    if (!m_pairingController || !m_appSettingsRepository) {
+        return;
+    }
+    if (generation != m_phoneSessionGeneration) {
+        return;
+    }
+
     auto gatewayController = QSharedPointer<GatewayController>::create(m_appSettingsRepository->getGatewayEndpoint(isTestPurchase),
                                                                        m_appSettingsRepository->isDevGatewayEnv(isTestPurchase),
                                                                        apiDefs::requestTimeoutMsecs,
                                                                        m_appSettingsRepository->isStrictKillSwitchEnabled());
 
     const QJsonObject payload = m_pairingController->buildScanQrPayload(qrUuid, vpnKey, serviceInfo, supportedProtocols, apiKey);
-    const QFuture<QPair<ErrorCode, QByteArray>> future = gatewayController->postAsync(QString::fromLatin1(kScanQrPath), payload);
+    QNetworkReply *replyRaw = nullptr;
+    const QFuture<QPair<ErrorCode, QByteArray>> future =
+            gatewayController->postAsync(QString::fromLatin1(kScanQrPath), payload, &replyRaw);
+    m_phoneNetworkReply = replyRaw;
 
     auto *watcher = new QFutureWatcher<QPair<ErrorCode, QByteArray>>(this);
     m_phoneWatcher = watcher;
     QObject::connect(watcher, &QFutureWatcher<QPair<ErrorCode, QByteArray>>::finished, this,
-                     [this, gatewayController, watcher]() {
+                     [this, gatewayController, watcher, generation, retryAttempt, qrUuid, isTestPurchase, vpnKey, serviceInfo,
+                      supportedProtocols, apiKey]() {
                          Q_UNUSED(gatewayController);
                          const auto result = watcher->result();
                          watcher->deleteLater();
@@ -254,26 +446,42 @@ void PairingUiController::runPhonePairingRequest(const QString &qrUuid, const bo
                              m_phoneWatcher.clear();
                          }
 
+                         if (generation != m_phoneSessionGeneration) {
+                             return;
+                         }
+
+                         m_phoneNetworkReply.clear();
+
+                         ErrorCode logicalErr = result.first;
+                         if (logicalErr == ErrorCode::NoError) {
+                             logicalErr = PairingController::parseScanQrResponseBody(result.second);
+                         }
+
+                         if (logicalErr == ErrorCode::NoError) {
+                             setPhoneBusy(false);
+                             m_phoneStatusMessage = tr("Sent successfully");
+                             emit phoneStatusMessageChanged();
+                             emit phonePairingSucceeded();
+                             return;
+                         }
+
+                         if (isPairingRetriableError(logicalErr) && retryAttempt + 1 < kPairingRetryMaxAttempts) {
+                             const int delayMs = pairingRetryDelayMs(retryAttempt);
+                             QTimer::singleShot(delayMs, this, [this, qrUuid, isTestPurchase, vpnKey, serviceInfo, supportedProtocols,
+                                                              apiKey, generation, retryAttempt]() {
+                                 if (generation != m_phoneSessionGeneration) {
+                                     return;
+                                 }
+                                 dispatchPhoneScanQrAttempt(qrUuid, isTestPurchase, vpnKey, serviceInfo, supportedProtocols, apiKey,
+                                                            generation, retryAttempt + 1);
+                             });
+                             return;
+                         }
+
                          setPhoneBusy(false);
-
-                         if (result.first != ErrorCode::NoError) {
-                             m_phoneStatusMessage = tr("Send failed");
-                             emit phoneStatusMessageChanged();
-                             emit errorOccurred(result.first);
-                             return;
-                         }
-
-                         const ErrorCode parseErr = PairingController::parseScanQrResponseBody(result.second);
-                         if (parseErr != ErrorCode::NoError) {
-                             m_phoneStatusMessage = tr("Send failed");
-                             emit phoneStatusMessageChanged();
-                             emit errorOccurred(parseErr);
-                             return;
-                         }
-
-                         m_phoneStatusMessage = tr("Sent successfully");
+                         m_phoneStatusMessage = tr("Send failed");
                          emit phoneStatusMessageChanged();
-                         emit phonePairingSucceeded();
+                         emit errorOccurred(logicalErr);
                      });
     watcher->setFuture(future);
 }

client/ui/controllers/api/pairingUiController.h

@@ -2,6 +2,7 @@
 #define PAIRINGUICONTROLLER_H
 
 #include <QFutureWatcher>
+#include <QNetworkReply>
 #include <QObject>
 #include <QVariantList>
 #include <QPointer>
@@ -26,11 +27,14 @@ class PairingUiController : public QObject
 
     Q_PROPERTY(bool phonePairingBusy READ phonePairingBusy NOTIFY phonePairingBusyChanged)
     Q_PROPERTY(QString phoneStatusMessage READ phoneStatusMessage NOTIFY phoneStatusMessageChanged)
+    /** TV flow for QA: 0=idle, 1=waitingForPeer, 2=error, 3=sessionExpired */
+    Q_PROPERTY(int tvPairingUiPhase READ tvPairingUiPhase NOTIFY tvPairingUiPhaseChanged)
 
 public:
     PairingUiController(PairingController *pairingController, ServersController *serversController,
                         SubscriptionController *subscriptionController, SecureAppSettingsRepository *appSettingsRepository,
                         QObject *parent = nullptr);
+    ~PairingUiController() override;
 
     QVariantList tvQrCodes() const;
     int tvQrCodesCount() const;
@@ -40,14 +44,27 @@ public:
 
     bool phonePairingBusy() const;
     QString phoneStatusMessage() const;
+    int tvPairingUiPhase() const { return m_tvPairingUiPhase; }
+
+#if defined(Q_OS_ANDROID)
+    static bool tryConsumeAndroidQrScan(const QString &code);
+#endif
 
 public slots:
     void startTvQrSession();
     void cancelTvQrSession();
+    /** TV receive + phone send: call when leaving QR pairing (back / pop) so long-poll state does not stick. */
+    void cancelAllPairingActivity();
 
     /** Sends the current premium/free API config from \a serverIndex to the gateway for the given \a qrUuid. */
     void submitPhonePairing(const QString &qrUuid, int serverIndex);
 
+    /** Android: system camera activity. iOS: toggle camera from QML. */
+    void openPairingQrScanner();
+
+    /** If \a raw contains a session UUID (not vpn://), emits pairingUuidFromScan and returns true. */
+    bool applyScannedTextAsPairingUuid(const QString &raw);
+
 signals:
     void errorOccurred(amnezia::ErrorCode errorCode);
     void tvQrCodesChanged();
@@ -60,12 +77,18 @@ signals:
     void tvPairingConfigReceived();
     void phonePairingSucceeded();
 
+    void pairingUuidFromScan(const QString &uuid);
+    void tvPairingUiPhaseChanged();
+
 private:
     void setTvBusy(bool busy);
     void setPhoneBusy(bool busy);
     void resetTvQrDisplay();
-    void runPhonePairingRequest(const QString &qrUuid, bool isTestPurchase, const QString &vpnKey, const QJsonObject &serviceInfo,
-                                const QJsonArray &supportedProtocols, const QString &apiKey);
+    QString tvFailureMessage(amnezia::ErrorCode code) const;
+    void dispatchTvGenerateQrAttempt(quint64 generation, int retryAttempt);
+    void dispatchPhoneScanQrAttempt(const QString &qrUuid, bool isTestPurchase, const QString &vpnKey, const QJsonObject &serviceInfo,
+                                    const QJsonArray &supportedProtocols, const QString &apiKey, quint64 generation, int retryAttempt);
+    void setTvPairingUiPhase(int phase);
 
     PairingController *m_pairingController {};
     ServersController *m_serversController {};
@@ -77,10 +100,15 @@ private:
     bool m_tvPairingBusy = false;
     QString m_tvStatusMessage;
     QPointer<QFutureWatcher<QPair<amnezia::ErrorCode, QByteArray>>> m_tvWatcher;
+    QPointer<QNetworkReply> m_tvNetworkReply;
+    quint64 m_tvSessionGeneration { 0 };
+    int m_tvPairingUiPhase { 0 };
 
     bool m_phonePairingBusy = false;
     QString m_phoneStatusMessage;
     QPointer<QFutureWatcher<QPair<amnezia::ErrorCode, QByteArray>>> m_phoneWatcher;
+    QPointer<QNetworkReply> m_phoneNetworkReply;
+    quint64 m_phoneSessionGeneration { 0 };
 };
 
 #endif // PAIRINGUICONTROLLER_H

client/ui/qml/Pages2/PageSettingsApiQrPairing.qml

@@ -2,6 +2,7 @@ import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
 
+import QRCodeReader 1.0
 import PageEnum 1.0
 import Style 1.0
 
@@ -14,6 +15,18 @@ PageType {
     id: root
 
     property int qrImageIndex: 0
+    property bool pairingCameraOpen: false
+
+    Connections {
+        target: root
+        function onVisibleChanged() {
+            if (!root.visible) {
+                pairingQrReader.stopReading()
+                root.pairingCameraOpen = false
+                PairingUiController.cancelAllPairingActivity()
+            }
+        }
+    }
 
     FlickableType {
         anchors.fill: parent
@@ -74,8 +87,9 @@ PageType {
                 Layout.fillWidth: true
                 Layout.leftMargin: 16
                 Layout.rightMargin: 16
-                defaultColor: "transparent"
                 text: qsTr("Cancel receive")
+                // Do not use defaultColor: transparent here: when enabled, BasicButtonType paints that
+                // as the idle background, so midnightBlack label sits on the page — invisible until hover.
                 enabled: PairingUiController.tvPairingBusy
                 clickedFunc: function() {
                     PairingUiController.cancelTvQrSession()
@@ -91,21 +105,29 @@ PageType {
                 wrapMode: Text.Wrap
             }
 
-            Image {
-                id: qrImage
-                Layout.alignment: Qt.AlignHCenter
+            // SVG QR from qrCodeUtils has a tiny viewBox (~45px); without a sized container + sourceSize it stays small.
+            Item {
+                id: qrBox
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
                 Layout.topMargin: 8
+                implicitHeight: width
                 visible: PairingUiController.tvQrCodesCount > 0
-                width: Math.min(220, parent.width - 32)
-                height: width
-                fillMode: Image.PreserveAspectFit
-                source: PairingUiController.tvQrCodesCount > 0 ? PairingUiController.tvQrCodes[root.qrImageIndex] : ""
 
-                MouseArea {
+                Image {
+                    id: qrImage
                     anchors.fill: parent
-                    enabled: PairingUiController.tvQrCodesCount > 1
-                    onClicked: {
-                        root.qrImageIndex = (root.qrImageIndex + 1) % PairingUiController.tvQrCodesCount
+                    fillMode: Image.PreserveAspectFit
+                    sourceSize: Qt.size(2048, 2048)
+                    source: PairingUiController.tvQrCodesCount > 0 ? PairingUiController.tvQrCodes[root.qrImageIndex] : ""
+
+                    MouseArea {
+                        anchors.fill: parent
+                        enabled: PairingUiController.tvQrCodesCount > 1
+                        onClicked: {
+                            root.qrImageIndex = (root.qrImageIndex + 1) % PairingUiController.tvQrCodesCount
+                        }
                     }
                 }
             }
@@ -130,12 +152,70 @@ PageType {
                 textField.placeholderText: qsTr("Paste UUID from TV QR")
             }
 
+            BasicButtonType {
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+                visible: Qt.platform.os === "android" || Qt.platform.os === "ios"
+                text: {
+                    if (Qt.platform.os === "ios" && root.pairingCameraOpen) {
+                        return qsTr("Hide camera")
+                    }
+                    return qsTr("Scan QR code")
+                }
+                enabled: !PairingUiController.phonePairingBusy
+                clickedFunc: function() {
+                    if (Qt.platform.os === "android") {
+                        PairingUiController.openPairingQrScanner()
+                    } else {
+                        root.pairingCameraOpen = !root.pairingCameraOpen
+                    }
+                }
+            }
+
+            Item {
+                id: cameraSlot
+                Layout.fillWidth: true
+                Layout.preferredHeight: (root.pairingCameraOpen && Qt.platform.os === "ios") ? 220 : 0
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+                visible: Layout.preferredHeight > 0
+                clip: true
+
+                // QRCodeReader is a QObject (not Item): no anchors; preview rect via setCameraSize like PageSetupWizardQrReader.
+                QRCodeReader {
+                    id: pairingQrReader
+
+                    onCodeReaded: function(code) {
+                        if (PairingUiController.applyScannedTextAsPairingUuid(code)) {
+                            pairingQrReader.stopReading()
+                            root.pairingCameraOpen = false
+                            PageController.showNotificationMessage(qsTr("Session ID filled from QR"))
+                        }
+                    }
+                }
+
+                onVisibleChanged: {
+                    if (!visible) {
+                        pairingQrReader.stopReading()
+                        return
+                    }
+                    if (Qt.platform.os === "ios") {
+                        Qt.callLater(function() {
+                            var p = cameraSlot.mapToItem(root, 0, 0)
+                            pairingQrReader.setCameraSize(Qt.rect(p.x, p.y, cameraSlot.width, cameraSlot.height))
+                            pairingQrReader.startReading()
+                        })
+                    }
+                }
+            }
+
             BasicButtonType {
                 Layout.fillWidth: true
                 Layout.leftMargin: 16
                 Layout.rightMargin: 16
                 text: PairingUiController.phonePairingBusy ? qsTr("Sending…") : qsTr("Send from current subscription")
-                enabled: !PairingUiController.tvPairingBusy && !PairingUiController.phonePairingBusy
+                enabled: !PairingUiController.phonePairingBusy
                 clickedFunc: function() {
                     PairingUiController.submitPhonePairing(uuidField.textField.text, ServersUiController.getProcessedServerIndex())
                 }
@@ -160,6 +240,11 @@ PageType {
             root.qrImageIndex = 0
         }
 
+        function onTvSessionUuidChanged() {
+            root.qrImageIndex = 0
+            uuidField.textField.text = PairingUiController.tvSessionUuid
+        }
+
         function onTvPairingConfigReceived() {
             PageController.showNotificationMessage(qsTr("Configuration received from gateway"))
         }
@@ -167,5 +252,9 @@ PageType {
         function onPhonePairingSucceeded() {
             PageController.showNotificationMessage(qsTr("Configuration sent"))
         }
+
+        function onPairingUuidFromScan(uuid) {
+            uuidField.textField.text = uuid
+        }
     }
 }