WebEngine Widgets Permission Browser Beispiel

Permission Browser demonstriert die Verwendung der Klasse QWebEnginePermission zur Verwaltung von Website-Berechtigungen. Das Beispiel enthält Code für die Bearbeitung eingehender Berechtigungsanfragen sowie für die Änderung bereits vorhandener Berechtigungen. Außerdem werden die Auswirkungen der verschiedenen Richtlinien zur Aufrechterhaltung von Berechtigungen gezeigt, die in der Klasse QWebEngineProfile definiert sind.

Ausführen des Beispiels

Zum Ausführen des Beispiels von Qt Creatorauszuführen, öffnen Sie den Modus Welcome und wählen Sie das Beispiel aus Examples. Weitere Informationen finden Sie unter Erstellen und Ausführen eines Beispiels.

Klassendefinitionen

Hauptfenster (MainWindow)

Die Klasse MainWindow erbt von QMainWindow. In ihr wird ein Zeiger auf QVBoxLayout deklariert, der die Widgets für die Bearbeitung der einzelnen Berechtigungen anzeigt, sowie ein weiterer Zeiger auf das Widget, das die aktuell anstehende Berechtigungsanfrage anzeigt. Außerdem deklarieren wir ein QWebEngineView, das zur Anzeige des eigentlichen Webseiteninhalts verwendet wird.

class MainWindow : public QMainWindow, public Ui_MainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(const QUrl &url);
    ~MainWindow();

private slots:
    void handlePermissionRequested(QWebEnginePermission permission);
    void handleUrlChanged(const QUrl &url);

    void handlePermissionModified(PermissionWidget *widget);
    void handleDeleteAllClicked();
    void handleNewClicked();
    void handleRefreshClicked();
    void handleBackClicked();
    void handleForwardClicked();
    void handlePolicyComboBoxIndexChanged(int index);

private:
    bool containsPermission(const QWebEnginePermission &permission);
    PermissionWidget *createPermissionWidget(const QWebEnginePermission &permission);
    void loadStoredPermissions();

    QVBoxLayout *m_layout;
    QWebEngineProfile *m_profile;
    QWebEngineView *m_webview;
    PermissionWidget *m_pendingWidget;
};

Der Rest des Layouts für die Anwendung ist in mainwindow.ui definiert und wurde mit dem Designmodus von Qt Creator erstellt. MainWindow ist eine Unterklasse von Ui_MainWindow, einer C++-Klasse, die zur Kompilierzeit aus den Definitionen in mainwindow.ui erzeugt wird.

PermissionWidget und PermissionDialog

Die Klasse PermissionWidget definiert ein Widget, das einer einzelnen Instanz von QWebEnginePermission entspricht. Der Einfachheit halber wird das QWebEnginePermission Objekt darin gespeichert. Das Widget selbst verfügt über Steuerelemente für die Erteilung, Verweigerung oder Löschung der Erlaubnis; all dies ist innerhalb von PermissionWidget.ui definiert.

class PermissionWidget : public QWidget, public Ui_PermissionWidget
{
    Q_OBJECT
public:
    PermissionWidget(const QWebEnginePermission &permission, QWidget *parent = nullptr);

    QWebEnginePermission m_permission;

signals:
    void permissionModified(PermissionWidget *widget);

private:
    void updateState();
};

Wenn man auf die Schaltfläche "Neu" in der Benutzeroberfläche des Hauptfensters klickt, erscheint ein Pop-up-Fenster, in dem der Benutzer die Erlaubnis für einen bekannten Ursprung vorab erteilen kann. Dieses Pop-up-Fenster wird durch die Klasse PermissionDialog definiert:

class PermissionDialog : public QDialog, public Ui_PermissionDialog
{
    Q_OBJECT
public:
    PermissionDialog(const QWebEngineProfile *profile, QWidget *parent = nullptr);
    ~PermissionDialog();
    QWebEnginePermission permission();

private:
    const QWebEngineProfile *m_profile;
    QWebEnginePermission *m_permission;
};

Behandlung eingehender Erlaubnisanfragen

Wann immer eine Website eine API verwendet, die die Privatsphäre des Benutzers gefährden könnte, wird erwartet, dass der Browser eine Eingabeaufforderung anzeigt, in der der Benutzer aufgefordert wird, die Erlaubnis entweder zu erteilen oder zu verweigern. Das PermissionBrowser-Beispiel hat einen eigenen Abschnitt unten rechts, der mit PermissionWidget gefüllt wird, wenn dies geschieht.

Die PermissionWidget zeigt den Ursprung der Erlaubnis, die angeforderte QWebEnginePermission::PermissionType sowie den aktuellen Status dieser Erlaubnis an. Außerdem gibt es Schaltflächen zum Erteilen und Verweigern der Berechtigung. Da der Berechtigungsstatus (standardmäßig) gespeichert wird, kann der Benutzer mit der Schaltfläche "Löschen" die Berechtigung aus dem zugrunde liegenden Speicher entfernen.

Um all dies zu erreichen, verbinden wir zunächst das Signal permissionRequested von QWebEnginePage mit dem Steckplatz handlePermissionRequested von MainWindow:

    connect(m_webview->page(), &QWebEnginePage::permissionRequested, this, &MainWindow::handlePermissionRequested);

Der Signalhandler ist relativ einfach: Er versucht, eine PermissionWidget -Instanz für das bereitgestellte QWebEnginePermission -Objekt zu erstellen, und wenn er erfolgreich ist, fügt er dieses Widget in das QFrame ein, das für ausstehende Berechtigungen vorgesehen ist. Wir abonnieren auch das Signal PermissionWidget's permissionModified, so dass wir später das PermissionWidget von unten rechts in die Liste der vorhandenen Widgets oben verschieben können.

void MainWindow::handlePermissionRequested(QWebEnginePermission permission)
{
    PermissionWidget *widget = createPermissionWidget(permission);
    if (widget) {
        m_pendingFrame->layout()->addWidget(widget);
        connect(widget, &PermissionWidget::permissionModified, this, &MainWindow::handlePermissionModified);

        if (m_pendingWidget)
            m_pendingWidget->deleteLater();

        m_pendingWidget = widget;
    }
}

Wir erstellen nur dann ein neues PermissionWidget, wenn wir noch kein bestehendes Widget haben:

PermissionWidget *MainWindow::createPermissionWidget(const QWebEnginePermission &permission)
{
    if (containsPermission(permission))
        return nullptr;

    return new PermissionWidget(permission, this);
}

Ändern einer Berechtigung und Anzeigen der Berechtigung für den Benutzer

Die Schnittstelle QWebEnginePermission bietet die Funktionen grant() und deny(), die ausreichen, um den Status einer Berechtigung zu ändern. Wenn die Anwendung eine Berechtigung vergessen muss, verwenden wir die Funktion reset().

Im PermissionWidget -Konstruktor verbinden wir diese Funktionen mit dem clicked -Signal der Schaltflächen, so dass wir die entsprechenden Funktionen auf dem QWebEnginePermission -Objekt ausführen können.

Jedes Mal, wenn eine Schaltfläche gedrückt wird, geben wir das Signal permissionModified aus, das MainWindow verwendet, um zu wissen, wann es das Widget von unten rechts in die Liste der vorhandenen Berechtigungen verschieben muss. Wir stellen auch sicher, dass wir updateState() aufrufen, das visuelle Aktualisierungen des Widgets vornimmt. Wenn die Löschtaste gedrückt wird, stellen wir sicher, dass das Widget zum Löschen markiert wird, da wir dem Benutzer nur die vorhandenen Berechtigungen anzeigen wollen.

PermissionWidget::PermissionWidget(const QWebEnginePermission &permission, QWidget *parent)
    : QWidget(parent)
    , m_permission(permission)
{
    setupUi(this);
    connect(m_deleteButton, &QPushButton::clicked, [this]() {
        m_permission.reset();
        emit permissionModified(this);
        deleteLater();
    });

    connect(m_grantButton, &QPushButton::clicked, [this]() {
        m_permission.grant();
        updateState();
        emit permissionModified(this);
    });

    connect(m_denyButton, &QPushButton::clicked, [this]() {
        m_permission.deny();
        updateState();
        emit permissionModified(this);
    });

    updateState();
}

Die Funktion updateState() zeigt dem Benutzer die von QWebEnginePermission gelieferten Daten an. Sie sorgt auch dafür, dass die Schaltflächen zum Erteilen oder Verweigern einer Berechtigung deaktiviert sind, wenn sich diese im Zustand QWebEnginePermission::Invalid befindet.

void PermissionWidget::updateState()
{
    switch (m_permission.state()) {
    case QWebEnginePermission::State::Invalid:
        m_stateLabel->setText("<font color='gray'>Invalid</font>");
        m_grantButton->setEnabled(false);
        m_denyButton->setEnabled(false);
        break;
    case QWebEnginePermission::State::Ask:
        m_stateLabel->setText("<font color='yellow'>Waiting for response</font>");
        break;
    case QWebEnginePermission::State::Granted:
        m_stateLabel->setText("<font color='green'>Granted</font>");
        break;
    case QWebEnginePermission::State::Denied:
        m_stateLabel->setText("<font color='red'>Denied</font>");
        break;
    }

    m_typeLabel->setText(QMetaEnum::fromType<QWebEnginePermission::PermissionType>().valueToKey((quint8)m_permission.permissionType()));
    m_originLabel->setText(m_permission.origin().toDisplayString());
}

Wenn eine ausstehende Berechtigung gewährt oder verweigert wird, wollen wir das zugehörige Widget in die Liste oben verschieben, die alle derzeit bestehenden Berechtigungen enthält. Wir tun dies im Slot MainWindow::handlePermissionModified.

void MainWindow::handlePermissionModified(PermissionWidget *widget)
{
    if (!m_pendingWidget || m_pendingWidget != widget)
        return;

    m_pendingFrame->layout()->removeWidget(widget);
    m_pendingWidget = nullptr;

    if (!QWebEnginePermission::isPersistent(widget->m_permission.permissionType())
        || widget->m_permission.state() == QWebEnginePermission::State::Ask
        || m_profile->persistentPermissionsPolicy() == QWebEngineProfile::PersistentPermissionsPolicy::AskEveryTime) {

        widget->deleteLater();
        return;
    }

    m_layout->insertWidget(0, widget);
}

Wir tun dies nur in den Fällen, in denen wir wissen, dass die Berechtigung gespeichert ist; einige PermissionTypes sind nicht persistent, was bedeutet, dass dem Benutzer bei jeder Verwendung eine Berechtigungsabfrage angezeigt werden muss. Wir schließen auch Berechtigungen mit dem Status QWebEnginePermission::Ask aus, was bedeutet, dass die Berechtigung reset() war, und wir fügen der Liste der bestehenden Berechtigungen nichts hinzu, wenn QWebEngineProfile::persistentPermissionsPolicy auf AskEveryTime gesetzt ist.

Anzeigen und Ändern bestehender Berechtigungen

Standardmäßig werden die Berechtigungen auf der Festplatte gespeichert und beim Start der Anwendung wieder abgerufen. Um eine Liste aller bestehenden Website-Berechtigungen zu erhalten, rufen wir QWebEngineProfile::listAllPermissions() auf:

void MainWindow::loadStoredPermissions()
{
    QList<QWebEnginePermission> permissionsList = m_profile->listAllPermissions();
    for (QWebEnginePermission &permission : permissionsList) {
        PermissionWidget *widget = createPermissionWidget(permission);
        if (widget)
            m_layout->insertWidget(0, widget);
    }
}

Für jede Berechtigung in der Liste konstruieren wir einfach eine neue PermissionWidget und fügen sie der Liste auf der rechten Seite des Bildschirms hinzu. Vorhandene Berechtigungen werden mit der gleichen API geändert wie die ausstehenden.

Vorab-Erteilung von Berechtigungen

Bestimmte Berechtigungen können im Voraus erteilt werden, sofern der Ursprung und der Berechtigungstyp bekannt sind. Wenn Sie auf die Schaltfläche "Neu" oben rechts klicken, wird ein Popup-Dialog geöffnet, der Ihnen genau das ermöglicht. Der Dialog wird von der Klasse PermissionDialog implementiert:

PermissionDialog::PermissionDialog(const QWebEngineProfile *profile, QWidget *parent)
    : QDialog(parent)
    , m_profile(profile)
    , m_permission(nullptr)
{
    setupUi(this);

    auto metaEnum = QMetaEnum::fromType<QWebEnginePermission::PermissionType>();
    Q_ASSERT(metaEnum.value((quint8)QWebEnginePermission::PermissionType::Unsupported) == 0);
    for (int i = 1; i < metaEnum.keyCount(); ++i) {
        QWebEnginePermission::PermissionType permissionType = QWebEnginePermission::PermissionType(metaEnum.value(i));
        if (QWebEnginePermission::isPersistent(permissionType))
            m_permissionTypeComboBox->addItem(metaEnum.valueToKey((quint8)permissionType), QVariant::fromValue(permissionType));
    }
}

Wir füllen QComboBox mit dem Typ QMetaEnum, der mit QWebEnginePermission::PermissionType verknüpft ist. Wir stellen sicher, dass nicht-persistente Berechtigungstypen herausgefiltert werden, da die Vorabvergabe dieser nicht unterstützt wird.

Wir zeigen das Dialogfeld an und fügen die resultierende PermissionWidget in der Benutzeroberfläche innerhalb des MainWindow::handleNewClicked Slots hinzu. Die neue Berechtigung wird genauso gehandhabt, wie wenn eine Website sie anfordern würde: durch den Aufruf von handlePermissionRequested().

void MainWindow::handleNewClicked()
{
    PermissionDialog dialog(m_profile);
    if (dialog.exec() == QDialog::Accepted) {
        handlePermissionRequested(dialog.permission());
    }
}

Ändern der Richtlinie zur Aufrechterhaltung von Berechtigungen

Standardmäßig werden die Berechtigungen für jede benannte QWebEngineProfile auf der Festplatte und für jede unbenannte/off-the-record-Berechtigung im Speicher gespeichert. Normalerweise wird diese Einstellung zur Laufzeit nicht geändert, aber in diesem Beispiel werden die Auswirkungen der einzelnen Optionen untersucht.

• QWebEngineProfile::StoreOnDisk ist die Standardeinstellung und stellt sicher, dass alle Berechtigungen, die im aktuellen Anwendungslauf gewährt wurden, beim nächsten Start wieder geladen werden. Eine Berechtigung muss nur einmal gewährt werden, und nachfolgende Verwendungen der API, die die Anforderung ausgelöst hat, werden automatisch gewährt, bis die Anwendung QWebEnginePermission::reset() aufruft.
• QWebEngineProfile::StoreInMemory Hat das gleiche Verhalten wie oben, außer dass die Berechtigungen beim Beenden der Anwendung zerstört und nicht auf die Festplatte übertragen werden.
• QWebEngineProfile::AskEveryTime stellt sicher, dass die Berechtigungen nie gespeichert werden und sich alle so verhalten, als wären sie nicht persistent. Daher wird jedes Mal, wenn eine Web-API eine Berechtigung benötigt, dem Benutzer eine neue Aufforderung angezeigt. Diese Option ist für Abwärtskompatibilität und Anwendungen gedacht, die ihre eigene Berechtigungsspeicherung implementieren.

Um sicherzustellen, dass dem Benutzer die bereits vorhandenen Berechtigungen angezeigt werden, müssen wir QWebEngineProfile::listAllPermissions() aufrufen:

void MainWindow::loadStoredPermissions()
{
    QList<QWebEnginePermission> permissionsList = m_profile->listAllPermissions();
    for (QWebEnginePermission &permission : permissionsList) {
        PermissionWidget *widget = createPermissionWidget(permission);
        if (widget)
            m_layout->insertWidget(0, widget);
    }
}

Dies geschieht einmalig beim Start sowie jedes Mal, wenn der Benutzer die Richtlinie auf QComboBox oben rechts ändert.

void MainWindow::handlePolicyComboBoxIndexChanged(int index)
{
    QWebEngineProfile::PersistentPermissionsPolicy policy;
    switch (index) {
    case 0:
        policy = QWebEngineProfile::PersistentPermissionsPolicy::AskEveryTime;
        break;
    case 1:
        policy = QWebEngineProfile::PersistentPermissionsPolicy::StoreInMemory;
        break;
    case 2:
        policy = QWebEngineProfile::PersistentPermissionsPolicy::StoreOnDisk;
        break;
    }

    if (policy == m_profile->persistentPermissionsPolicy())
        return;

    for (int i = m_layout->count() - 1; i >= 0; i--) {
        PermissionWidget *widget = qobject_cast<PermissionWidget *>(m_layout->itemAt(i)->widget());
        if (!widget)
            continue;

        widget->deleteLater();
    }

    m_profile->setPersistentPermissionsPolicy(policy);
    loadStoredPermissions();
}

Beispielprojekt @ code.qt.io