QtWebEnginePlugins es un conjunto de componentes proporcionados por el marco Qt para extender QtWebEngine. Se implementan integrando el motor web proporcionado por el proyecto Chromium. Un motor web es un componente de software para cargar y representar contenido web, y QtWebEnginePlugins lo amplía para admitir más funciones y formatos de contenido web.
Arquitectura subyacente:
El interior de QtWebEnginePlugins consta de varias clases, las más importantes son QWebEnginePlugin y QWebEnginePluginFactory. QWebEnginePlugin es una clase abstracta utilizada para extender QtWebEngine, que proporciona un conjunto de funciones para cargar y procesar formatos de contenido web específicos. QWebEnginePluginFactory es responsable de gestionar la creación y destrucción de QWebEnginePlugin. La arquitectura subyacente de QWebEnginePlugin se basa en el motor web del proyecto Chromium, que utiliza una arquitectura multiproceso para expandir el contenido web.
Realizar el diagrama de arquitectura:
+-----------------+ +------------------------+
| | | |
| QWebEnginePlugin| | QWebEnginePluginFactory|
| | | |
+--------+--------+ +-----------+------------+
| |
| IPC |
+------------------------------------+
|
|
+--------v---------+
| |
| Web Content |
| Process |
| |
+------------------+
La comunicación entre QWebEnginePlugin y el proceso de contenido web se realiza a través de IPC. Cuando QWebEnginePlugin carga una página web, envía un mensaje al proceso de contenido web, solicitando al proceso que cargue un formato de contenido web específico. El proceso de contenido web es responsable de cargar ese contenido y enviar los datos de la imagen renderizada a QWebEnginePlugin. QWebEnginePlugin convierte estos datos de imagen a un formato que QQuickItem puede mostrar y lo muestra en QQuickWebEngineView.
Descripción detallada de la operación del principio:
El uso de QWebEnginePlugin es muy simple, basta con crear una subclase heredada de QWebEnginePlugin e implementar su función virtual pura. Por ejemplo, el siguiente código crea una subclase QWebEnginePlugin denominada MyPlugin:
class MyPlugin : public QWebEnginePlugin
{
Q_OBJECT
public:
MyPlugin(QObject* parent = nullptr);
QStringList keys() const override;
bool supportsExtension(const QWebEnginePlugin::Extension extension) const override;
QObject* createExtension(const QWebEnginePlugin::Extension extension, const QWebEnginePlugin::Arguments& arguments) override;
};
En el código anterior, la subclase MyPlugin implementa tres funciones virtuales puras: keys(), supportExtension() y createExtension(). La función keys() devuelve una lista de tipos MIME para formatos de contenido web admitidos. La función supportExtension() se utiliza para comprobar si se admite el formato de contenido web especificado. La función createExtension() se usa para crear una instancia de QWebEnginePluginExtension para procesar el formato de contenido web especificado.
El uso de QWebEnginePluginFactory es un poco más complicado. Primero, debe crear una subclase heredada de QWebEnginePluginFactory e implementar su función virtual pura. Por ejemplo, el siguiente código crea una subclase QWebEnginePluginFactory denominada MyPluginFactory:
class MyPluginFactory : public QWebEnginePluginFactory
{
Q_OBJECT
public:
MyPluginFactory(QObject* parent = nullptr);
QList<QWebEnginePlugin*> plugins() const override;
};
En el código anterior, la subclase MyPluginFactory implementa la función plugins(), que devuelve un conjunto de instancias de QWebEnginePlugin. Estas instancias serán utilizadas por QtWebEngine para extender su soporte para formatos de contenido web.
Aquí hay un ejemplo simple de QML que demuestra cómo usar QWebEnginePlugin:
import QtQuick 2.0
import QtWebEngine 1.0
Item {
width: 400
height: 400
QQuickWebEngineView {
id: view
anchors.fill: parent
url: "http://www.example.com"
}
MyPlugin {
id: plugin
}
MouseArea {
anchors.fill: parent
onClicked: {
var extensions = plugin.extensions()
for (var i = 0; i < extensions.length; i++) {
var extension = extensions[i]
if (extension.supported()) {
extension.load(view)
}
}
}
}
En el código anterior, primero cargamos una página web a través de QQuickWebEngineView. Luego, creamos una instancia de MyPlugin y la agregamos al QML. Finalmente, en el controlador de señales onClicked de MouseArea, iteramos sobre las instancias de QWebEnginePluginExtension en MyPlugin y usamos las extensiones admitidas para cargar el contenido web.
El principio de usar funciones en la clase:
La función más importante de la clase QWebEnginePlugin es createExtension(), que se utiliza para crear una instancia de QWebEnginePluginExtension para procesar el formato de contenido web especificado. QWebEnginePluginExtension es una clase abstracta para procesar formatos de contenido web específicos, que proporciona un conjunto de funciones para cargar y procesar contenido web.
La función más importante de la clase QWebEnginePluginFactory es plugins(), que devuelve un conjunto de instancias de QWebEnginePlugin. Estas instancias serán utilizadas por QtWebEngine para extender su soporte para formatos de contenido web.
Aquí hay un ejemplo de implementación simple:
//MyPlugin.cpp
#include "MyPlugin.h"
#include "MyPluginExtension.h"
MyPlugin::MyPlugin(QObject* parent)
: QWebEnginePlugin(parent)
{
}
QStringList MyPlugin::keys() const
{
return QStringList() << "application/myplugin";
}
bool MyPlugin::supportsExtension(const QWebEnginePlugin::Extension extension) const
{
return extension == QWebEnginePlugin::PdfViewer;
}
QObject* MyPlugin::createExtension(const QWebEnginePlugin::Extension extension, const QWebEnginePlugin::Arguments& arguments)
{
if (extension == QWebEnginePlugin::PdfViewer) {
return new MyPluginExtension(arguments.webContents);
}
return nullptr;
}
//MyPluginFactory.cpp
#include "MyPluginFactory.h"
#include "MyPlugin.h"
MyPluginFactory::MyPluginFactory(QObject* parent)
: QWebEnginePluginFactory(parent)
{
}
QList<QWebEnginePlugin*> MyPluginFactory::plugins() const
{
QList<QWebEnginePlugin*> plugins;
plugins.append(new MyPlugin(this));
return plugins;
}
//MyPluginExtension.h
#include <QWebEnginePlugin>
#include <QWebEnginePage>
class MyPluginExtension : public QWebEnginePluginExtension
{
Q_OBJECT
public:
MyPluginExtension(QWebEnginePage* page);
bool supported() const override;
void load(QQuickItem* item) override;
private:
QWebEnginePage* m_page;
};
//MyPluginExtension.cpp
#include "MyPluginExtension.h"
MyPluginExtension::MyPluginExtension(QWebEnginePage* page)
: m_page(page)
{
}
bool MyPluginExtension::supported() const
{
return true;
}
void MyPluginExtension::load(QQuickItem* item)
{
QWebEngineView* view = new QWebEngineView(item);
view->setPage(m_page);
view->load(QUrl("http://www.example.com"));
item->window()->show();
}
En el código anterior, primero creamos una clase MyPlugin, que hereda de QWebEnginePlugin e implementa tres funciones virtuales puras. Admite formatos de contenido web con tipo MIME "application/myplugin" y usa MyPluginExtension para manejar la extensión QWebEnginePlugin::PdfViewer. Luego, creamos una clase MyPluginFactory, que hereda de QWebEnginePluginFactory e implementa la función plugins(), que devuelve una lista de instancias de MyPlugin. Finalmente, creamos una clase MyPluginExtension que hereda de QWebEnginePluginExtension e implementa las funciones support() y load(). Admite todos los formatos de contenido web y carga una página web en la función load().