qt cef嵌入web

Posted 朝闻道

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了qt cef嵌入web相关的知识,希望对你有一定的参考价值。

原文http://blog.sina.com.cn/s/blog_9e59cf590102vnfc.html

最近项目需要,研究了下libcef库。

Cef(Chromium Embedded Framework)简述

嵌入式Chromium框架(简称CEF) 是一个由Marshall Greenblatt在2008建立的开源项目,它主要目的是开发一个基于Google Chromium的Webbrowser控件。CEF支持一系列的编程语言和操作系统,并且能很容易地整合到新的或已有的工程中去。

它的设计思想政治就是易用且兼顾性能。CEF基本的框架包含C/C++程序接口,通过本地库的接口来实现,而这个库则会隔离宿主程序和Chromium&Webkit的操作细节。它在浏览器控件和宿主程序之间提供紧密的整合,它支持用户插件,协议,javascript对象以及javascript扩展,宿主程序可以随意地控件资源下载,导航和打印等,并且可以跟Google Chrome浏览器一起,支持高性能和html5 技术。

Cef使用

首先下载cef库的源码,源码有2个大的版本,cef1和cef3,我使用的是cef3,因此cef1我就不过多解释,其实我也不太了解。刚开始使用的时候一定不能怕,可能有些人看了源码之后会发现源码异常的复杂,这个时候我建议网上多差点儿资料,因为我学的时候也是在网上找到了不少好的文章。

下边是我在编译cef库的时候遇到的一些问题:

  • 因为我的项目是基于qt的来做的,而qt的运行时库是MDd类型的,因此cef3编译的时候也应该遵循这个运行时库的编译方式

  • 我在网上也看到了不少介绍创建cef项目的办法,不过个人觉得好多都是只讲过程,不讲原理,其实使用这个库很简单,我直- 说debug模式,release照搬。首先拷贝exe执行所需资源文件和运行时库(Resources目录下的除include文件夹、Debug目录下所有动态库),然后拷贝连接器的静态库(out/Debug/lib目录下的静态库、Debug目录下的所有静态库)

  • 根据个人使用工具的不同自行包含头文化和静态库,我使用的是vs2013,工程属性->配置属性->VC++目录,添加包含目录和库目录,在工程属性->配置属性->连接器->输入,页面附加依赖项添加依赖动态库

以上这3项基本就满足了创建包含cef项目的所有注意事项,如果自己想定制更好使用的控件,则需要相应的代码级别操作,接下来,我就讲讲代码级别基本的操作,复杂的操作我现在也了解不多。

  • 注释:关于libCef库中每个类的作用,我就不多说了,自己网上随便一搜索一大堆,在这里我直说几个重要的,在我的项目里使用到的:

  • CefDownloadHandler:下载回调类,当web页面上有文件下载的时候,会调用该类中的相应接口。注意一点,cef库默认是禁止了文件下载,如果想要响应这一事件,需要在OnBeforeDownload重写接口中加入代码:callback->Continue(suggested_name, true);
  • CefClient:获取注册回调类
  • CefDisplayHandler:地址、标题等改变调用接口,重写此类可以处理导航相关事件
  • CefRenderProcessHandler:渲染进程,当浏览器创建的时候,该类中的接口会被调用,因此可是在该类的接口中注册方法或者对象到web。包含webkit初始化、导航、上下文创建等回调接口
  • CefBrowserProcessHandler:浏览器进程,上下文初始化、渲染进程创建等回调接口

cef库嵌入已有工程步骤:

1、首先需要自己集成QWidget,重写一个web窗口,如图1所示;

2、main.cpp函数添加如图2所示方法,main方法中初始化Cef库,代码如下,退出时调用CefQuit();

int result = CefInit(argc, argv);
if (result >= 0)
{
return result;
}
CefLoadPlugins(IsWow64());

图1

图2

图3

图4

3、QCefWebView,重写ClientApp::RenderDelegate的方法OnContextCreated,完成对象和方法的注册,代码如图3,图中CefMapV8handler是js在调用该接口时的回调类,该类继承自CefV8Handler,我们只需要重写该类中的Execute接口,然后根据参数name来获取js调用的是qt的哪个接口,如图4所示。

4、最后也是最终的部分,我贴上cef库初始化和我自己封装的类文件源代码,当然了,有很大一部分代码也是从网上找的

相关代码如下

cefclient.h如下:

// Initialize CEF.
int CefInit(int &argc, char **argv);

// Load web plugins.
void CefLoadPlugins(bool isWow64);

// Quit CEF.
void CefQuit();

// Quit CEF until all browser windows have closed.
void CefQuitUntilAllBrowserClosed();

// Returns the application working directory.
QString AppGetWorkingDirectory();

// Notify all browser windows have closed.
void NotifyAllBrowserClosed();

cefclient.cpp如下

namespace {
    // Initialize the CEF settings.
    void CefInitSettings(CefSettings& settings)
    {
        // Make browser process message loop run in a separate thread.
        settings.multi_threaded_message_loop = true;
        // Store cache data will on disk.
        std::string cache_path = QString2StdStr(AppGetWorkingDirectory()) + "/.cache";
        CefString(&settings.cache_path) = CefString(cache_path);
        // Completely disable logging.
        settings.log_severity = LOGSEVERITY_DISABLE;
        // The resources(cef.pak and/or devtools_resources.pak) directory.
        CefString(&settings.resources_dir_path) = CefString();
        // The locales directory.
        CefString(&settings.locales_dir_path) = CefString();
        // Enable remote debugging on the specified port.
        settings.remote_debugging_port = 8088;
        // Ignore errors related to invalid SSL certificates.
        //settings.ignore_certificate_errors = true;
    }

}  // namespace

CefRefPtr g_handler;
CefRefPtr g_appHandler;

int CefInit(int &argc, char **argv)
{
    qDebug() << __FUNCTION__;
    HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);

    CefMainArgs main_args(hInstance);
    g_appHandler = new ClientApp;
    CefRefPtr app(g_appHandler);

    // Execute the secondary process, if any.
    int exit_code = CefExecuteProcess(main_args, app.get(), NULL);
    if (exit_code >= 0)
        return exit_code;

    CefSettings settings;
    CefInitSettings(settings);

#ifndef SUB_PROCESS_DISABLED
    // Specify the path for the sub-process executable.
    CefString(&settings.browser_subprocess_path).FromASCII("cefclient_process.exe");
#endif

    settings.single_process = true;

    settings.no_sandbox = true;
    settings.multi_threaded_message_loop = true;

    // Initialize CEF.
    CefInitialize(main_args, settings, app.get(), NULL);

    g_handler = new ClientHandler();

    return -1;
}

void CefLoadPlugins(bool isWow64)
{
    CefString flash_plugin_dir = isWow64 ? "C:\\\\Windows\\\\SysWOW64\\\\Macromed\\\\Flash"
        : "C:\\\\Windows\\\\System32\\\\Macromed\\\\Flash";
    CefAddWebPluginDirectory(flash_plugin_dir);

    CefRefreshWebPlugins();
}

void CefQuit()
{
    qDebug() << __FUNCTION__;
    // Shut down CEF.
    CefShutdown();
}

qcefwebview.h如下:

class QCefWebView : public QWidget
    , public ClientHandler::Listener
    , public ClientApp::RenderDelegate
{
    Q_OBJECT

public:
    enum BrowserState
    {
        kNone,
        kCreating,
        kCreated,
    };

    static const QString kUrlBlank;

    QCefWebView(QWidget* parent = 0);
    virtual ~QCefWebView();

    void load(const QUrl& url);
    void setHtml(const QString& html, const QUrl& baseUrl = QUrl());
    QUrl url() const;

    public slots:
    void back();
    void forward();
    void reload();
    void stop();

    QVariant evaluateJavaScript(const QString& scriptSource);//执行js脚本

signals:
    void titleChanged(QString title);
    void urlChanged(QUrl url);
    void loadStarted();
    void loadFinished(bool ok);
    void webRequest(const QString & title);

    void navStateChanged(bool canGoBack, bool canGoForward);
    void jsMessage(QString name, QVariantList args);

protected:
    virtual void resizeEvent(QResizeEvent*);
    virtual void closeEvent(QCloseEvent*);
    virtual void showEvent(QShowEvent*);
    virtual void customEvent(QEvent*);
    //ClientHandler::Listener 
    virtual void OnAddressChange(const QString& url);
    virtual void OnTitleChange(const QString& title);
    virtual void SetLoading(bool isLoading);
    virtual void SetNavState(bool canGoBack, bool canGoForward);
    virtual void OnAfterCreated();
    virtual void OnMessageEvent(MessageEvent* e);
    virtual void OnWebRequest(const QString & order);

    //ClientApp::RenderDelegate
    virtual void OnContextCreated(CefRefPtr app,
        CefRefPtr browser,
        CefRefPtr frame,
        CefRefPtr context);
private:
    bool CreateBrowser(const QSize& size);
    CefRefPtr GetBrowser() const;
    void ResizeBrowser(const QSize& size);
    bool BrowserLoadUrl(const QUrl& url);

    BrowserState browser_state_;
    bool need_resize_;
    bool need_load_;
    QUrl url_;
    QMutex mutex_;

    Q_DISABLE_COPY(QCefWebView);
    IMPLEMENT_REFCOUNTING(QCefWebView);
};

qcefwebview.cpp如下:

extern CefRefPtr g_handler;
extern CefRefPtr g_appHandler;

const QString QCefWebView::kUrlBlank = "about:blank";

QCefWebView::QCefWebView(QWidget* parent)
    : QWidget(parent),
    browser_state_(kNone),
    need_resize_(false),
    need_load_(false)
{
    setAttribute(Qt::WA_NativeWindow);
    setAttribute(Qt::WA_DontCreateNativeAncestors);
}

QCefWebView::~QCefWebView()
{
}

void QCefWebView::load(const QUrl& url)
{
    url_ = url;
    switch (browser_state_)
    {
    case kNone:
        CreateBrowser(size()); break;
    case kCreating:
        // If resizeEvent()/showEvent() before you load a url, it will
        // CreateBrowser() as soon as possible with "about:blank".
        need_load_ = true; break;
    default:  // The browser should have been created.
        BrowserLoadUrl(url);
    }
}

void QCefWebView::setHtml(const QString& html, const QUrl& baseUrl)
{
    if (GetBrowser().get())
    {
        QUrl url = baseUrl.isEmpty() ? this->url() : baseUrl;
        if (!url.isEmpty())
        {
            CefRefPtr frame = GetBrowser()->GetMainFrame();
            frame->LoadString(CefString(html.toStdWString()),
                CefString(url.toString().toStdWString()));
        }
    }
}

QUrl QCefWebView::url() const {
    if (GetBrowser().get())
    {
        CefString url = GetBrowser()->GetMainFrame()->GetURL();
        return QUrl(QString::fromStdWString(url.ToWString()));
    }
    return QUrl();
}

void QCefWebView::back()
{
    CefRefPtr browser = GetBrowser();
    if (browser.get())
        browser->GoBack();
}

void QCefWebView::forward()
{
    CefRefPtr browser = GetBrowser();
    if (browser.get())
        browser->GoForward();
}

void QCefWebView::reload()
{
    CefRefPtr browser = GetBrowser();
    if (browser.get())
        browser->Reload();
}

void QCefWebView::stop()
{

    CefRefPtr browser = GetBrowser();
    if (browser.get())
        browser->StopLoad();
}

QVariant QCefWebView::evaluateJavaScript(const QString& scriptSource)
{
    if (GetBrowser().get())
    {
        CefString code(scriptSource.toStdWString());
        GetBrowser()->GetMainFrame()->ExecuteJavaScript(code, "", 0);
        return true;
    }
    return false;
}

void QCefWebView::resizeEvent(QResizeEvent* e)
{
    switch (browser_state_)
    {
    case kNone:
        CreateBrowser(e->size()); break;
    case kCreating:
        need_resize_ = true; break;
    default:
        ResizeBrowser(e->size());
    }
}

void QCefWebView::closeEvent(QCloseEvent* e)
{
    if (g_handler.get() && !g_handler->IsClosing())
    {
        CefRefPtr browser = g_handler->GetBrowser();
        if (browser.get())
        {
            browser->GetHost()->CloseBrowser(false);
        }
    }
    e->accept();
}

void QCefWebView::showEvent(QShowEvent* e)
{
    CreateBrowser(size());
}

void QCefWebView::customEvent(QEvent* e)
{
    if (e->type() == MessageEvent::MessageEventType)
    {
        MessageEvent* event = static_cast(e);
        QString name = event->name();
        QVariantList args = event->args();
        emit jsMessage(name, args);
    }
}

void QCefWebView::OnAddressChange(const QString& url)
{
    if (url != "about:blank")
    {
        emit urlChanged(QUrl(url));
    }
}

void QCefWebView::OnTitleChange(const QString& title)
{
    emit titleChanged(title);
}

void QCefWebView::SetLoading(bool isLoading)
{
    if (isLoading)
    {
        if (!need_load_ && !url_.isEmpty())
            emit loadStarted();
    }
    else
    {
        if (need_load_)
        {
            BrowserLoadUrl(url_);
            need_load_ = false;
        }
        else if (!url_.isEmpty())
        {
            emit loadFinished(true);
        }
    }
}

void QCefWebView::SetNavState(bool canGoBack, bool canGoForward)
{
    emit navStateChanged(canGoBack, canGoForward);
}

void QCefWebView::OnAfterCreated()
{
    browser_state_ = kCreated;
    if (need_resize_)
    {
        ResizeBrowser(size());
        need_resize_ = false;
    }
}

void QCefWebView::OnMessageEvent(MessageEvent* e)
{
    QCoreApplication::postEvent(this, e, Qt::HighEventPriority);
}

void QCefWebView::OnWebRequest(const QString & order)
{
    emit webRequest(order);
}

bool QCefWebView::CreateBrowser(const QSize& size)
{
    if (browser_state_ != kNone || size.isEmpty())
    {
        return false;
    }
    mutex_.lock();
    if (browser_state_ != kNone)
    {
        mutex_.unlock();
        return false;
    }
    RECT rect;
    rect.left = 0;
    rect.top = 0;
    rect.right = size.width();
    rect.bottom = size.height();

    CefWindowInfo info;
    CefBrowserSettings settings;

    info.SetAsChild((HWND)this->winId(), rect);

    g_handler->set_listener(this);
    g_appHandler->insertMainRenderDelegate(this);

    QString url = url_.isEmpty() ? kUrlBlank : url_.toString();
    CefBrowserHost::CreateBrowser(info,
        g_handler.get(),
        CefString(url.toStdWString()),
        settings,
        NULL);

    browser_state_ = kCreating;
    mutex_.unlock();
    return true;
}

CefRefPtr QCefWebView::GetBrowser() const
{
    CefRefPtr browser;
    if (g_handler.get())
        browser = g_handler->GetBrowser();
    return browser;
}

void QCefWebView::ResizeBrowser(const QSize& size)
{
    if (g_handler.get() && g_handler->GetBrowser())
    {
        CefWindowHandle hwnd =
            g_handler->GetBrowser()->GetHost()->GetWindowHandle();
        if (hwnd)
        {
            HDWP hdwp = BeginDeferWindowPos(1);
            hdwp = DeferWindowPos(hdwp, hwnd, NULL,
                0, 0, size.width(), size.height(),
                SWP_NOZORDER);
            EndDeferWindowPos(hdwp);
        }
    }
}

bool QCefWebView::BrowserLoadUrl(const QUrl& url)
{
    if (!url.isEmpty() && GetBrowser().get())
    {
        CefString cefurl(url_.toString().toStdWString());
        GetBrowser()->GetMainFrame()->LoadURL(cefurl);
        return true;
    }
    return false;
}

void QCefWebView::OnContextCreated(CefRefPtr app
    , CefRefPtr browser
    , CefRefPtr frame
    , CefRefPtr context)
{
    CefRefPtr object = context->GetGlobal();

    CefRefPtr myV8Acc = new QCefV8Accessor;
    CefRefPtr val = CefV8Value::CreateString(L"videoHandler");
    CefString cefException;
    myV8Acc->Set(L"videoHandler", object, val, cefException);
    CefRefPtr pObjApp = CefV8Value::CreateObject(myV8Acc);
    object->SetValue(L"videoHandler", pObjApp, V8_PROPERTY_ATTRIBUTE_NONE);

    CefRefPtr mapHandler = new CefMapV8Handler(g_appHandler);

    CefRefPtr ExecuteRequestOrder =
        CefV8Value::CreateFunction("ExecuteRequestOrder", mapHandler);

    object->SetValue("ExecuteRequestOrder", ExecuteRequestOrder, V8_PROPERTY_ATTRIBUTE_NONE);
}

注意:以上代码只提供了一个思路,还有部分处理代码我没有贴出来,但是在论述的时候我都已经提到了,有C++基础的就基本可以搞定了,上述功能完成后就基本可以实现嵌入web的功能了。

后续

上述并不完美,因为如果需要在多个窗口上创建cef浏览器部件的话,在消息监听部分没有办法做区分多个浏览器事件,在这篇文章中我将会把上一篇相关文章中的程序结构稍作改动,以支持多个主浏览器窗口,主要是针对不同的浏览器产生事件时分发给不同的监听者,说到这儿,有的读者应该就能想到了,监听者肯定是一个数组了,而且 个数和浏览器数目一样多。

在接着往一下看的时候,我默认大家都已经完成创建浏览器并可以成功监听事件。

我先讲下思路:主要围绕每一个窗口创建一个浏览器每一个浏览器同时又是一个监听者。当显示窗口的时候,创建浏览器,并把当前窗口的id和指针保存到ClientHandler对象中,在浏览器创建成功并回调OnAfterCreated接口时,使用当前浏览器句柄匹配保存在ClientHandler中的浏览器父窗口句柄,如果匹配成功,则把以监听者为键,以浏览器为值的简直对保存起来,这个键值对是作为后面libcef事件回调时通知指定监听者的依据。

上面的思路可能理解起来有点儿绕,接下来我直接上关键性代码,希望大家能更好的理解

typedef std::map ListenerHwnds; 

ListenerHwnds listenerHwnds_;//浏览器父窗口、监听者对

typedef std::map > ListenerBrowserMap;

ListenerBrowserMap m_MainBrowsers;//监听者、浏览器对

图1

图1 是浏览器创建成功后的回调,在该方法中添加监听者/浏览器对到ClientHandler中,当浏览器发生事件回调的时候,调用指定的监听者

图2

图2 的代码是设置是否进行加载,根据ClientHanlder中已经注册的监听者/浏览器对,把浏览器事件发送给指定监听者

图3

图3 是有两个方法,方法1是保存监听者到CliendHandler对象中,在方法在浏览器创建之前调用;方法2是获取当前所有浏览器

图4

图4 是创建浏览器代码,在调用CreateVrowser方法创建浏览器之前需要保存窗口句柄和指针到ClientHandler对象中,以备图1所示代码所用,保存代码如上图中有下划线部分。
由于在上一篇相关文档中已经可以成功创建出浏览器,故这篇文章跳跃性比较大,如果有不理解的地方可以去看上一篇文章。

至此,文章都是个人理解,有问题请留言

 

http://www.cnblogs.com/oloroso/p/6051631.html

以上是关于qt cef嵌入web的主要内容,如果未能解决你的问题,请参考以下文章

Qt嵌入浏览器(五)——CEF入口与QCefView控件的使用

QT CEF3 消息循环处理

Qt嵌入浏览器(六)——QCefView实现JS通信接口

Web前端项目的跨平台桌面客户端打包方案之——CEF框架

Web前端项目的跨平台桌面客户端打包方案之——CEF框架

Qt5.9.1结合REF开发基于chorm的浏览器