C++单例类注册到qml模块与之交互

我们都知道C++注册到qml文件中，可以在qml文件中作为元素类型来使用，每个qml文件可以使用注册过的C++文件里的类，本篇介绍C++单例类注册到qml文件中，这样就可以在不同的qml使用中，同时，如果单例类发信号，每个qml文件中有写信号接收的地方都可以收到单例发出来的信号，这样方便不同的界面可以同步同一状态或效果。下面请看具体的代码示例：

#ifndef SYSTEMINFO_H
#define SYSTEMINFO_H

#include <QObject>
#include <QSysInfo>

class SystemInfo: public QObject
{
    Q_OBJECT

public:
    SystemInfo(QObject *parent = nullptr);

    static SystemInfo* instance();


    Q_INVOKABLE QByteArray bootUniqueId();
    Q_INVOKABLE QString buildAbi();
    Q_INVOKABLE QString buildCpuArchitecture();
    Q_INVOKABLE QString currentCpuArchitecture();
    Q_INVOKABLE QString kernelType();
    Q_INVOKABLE QString kernelVersion();
    Q_INVOKABLE QString machineHostName();
    Q_INVOKABLE QByteArray machineUniqueId();
    Q_INVOKABLE QString prettyProductName();
    Q_INVOKABLE QString productType();
    Q_INVOKABLE QString productVersion();

    Q_INVOKABLE QString getText();

signals:
    void signalGetSystemInfo();//const QJsonObject &jsonObject


private:

};

#endif // SYSTEMINFO_H

#include "systeminfo.h"


static SystemInfo* __systemInfo = nullptr;


SystemInfo::SystemInfo(QObject *parent)
    :QObject(parent)
{

}

SystemInfo *SystemInfo::instance()
{
    if(__systemInfo == nullptr){
        __systemInfo = new SystemInfo();
    }
    return __systemInfo;
}

QByteArray SystemInfo::bootUniqueId()
{
    return QSysInfo::bootUniqueId();
}

QString SystemInfo::buildAbi()
{
    return QSysInfo::buildAbi();
}

QString SystemInfo::buildCpuArchitecture()
{
    return QSysInfo::buildCpuArchitecture();
}

QString SystemInfo::currentCpuArchitecture()
{
    return QSysInfo::currentCpuArchitecture();
}

QString SystemInfo::kernelType()
{
    return QSysInfo::kernelType();
}

QString SystemInfo::kernelVersion()
{
    return QSysInfo::kernelVersion();
}

QString SystemInfo::machineHostName()
{
    return QSysInfo::machineHostName();
}

QByteArray SystemInfo::machineUniqueId()
{
    return QSysInfo::machineUniqueId();
}

QString SystemInfo::prettyProductName()
{
    return QSysInfo::prettyProductName();
}

QString SystemInfo::productType()
{
    return QSysInfo::productType();
}

QString SystemInfo::productVersion()
{
    return QSysInfo::productVersion();
}

QString SystemInfo::getText()
{
    return QString("camle");
}

#ifndef TIMESERVICE_H
#define TIMESERVICE_H

#include <QObject>
#include <QJsonObject>
#include <QMap>


class TimeService : public QObject
{
    Q_OBJECT
public:
    enum TimeType{
        UnKnowed = 0,
        IntType, //整形
        DoubleType,//浮点型
    };
    Q_ENUM(TimeType)
    static TimeService* instance();

    ~TimeService();

    ///获取时间
    Q_INVOKABLE QJsonObject getTimeObject(const QString &index);

    /// 设置时间
    Q_INVOKABLE void setTimeObject(QString index, const QJsonObject& timeData);

    Q_INVOKABLE int countTimeObject();


signals:
    void signalTimeCount(int nCount);


public slots:
    void slotGetTimeFinish();

private:
    explicit TimeService(QObject *parent = nullptr);

public:
    ///关闭时间集合<群id, json{closeTime, time}>


private:
    QMap<QString, QJsonObject> m_mapTime;
};

#endif // GROUPSERVICE_H

#include "timeservice.h"
#include <QCoreApplication>
#include <QSettings>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonParseError>
#include <QDebug>
#include <QJsonDocument>
#include "iostream"
#include <string>



static TimeService* __timeService = nullptr;


TimeService::TimeService(QObject *parent)
    : QObject(parent)
{

}

QJsonObject TimeService::getTimeObject(const QString &index)
{
    if(m_mapTime.contains(index))
    {
        QJsonObject jsonObject = m_mapTime.value(index);
        return jsonObject;
    }

    return QJsonObject();

}

void TimeService::setTimeObject(QString index, const QJsonObject& timeData)
{
    m_mapTime.insert(index, timeData);
    emit signalTimeCount(23);
}

int TimeService::countTimeObject()
{
    return m_mapTime.count();
}



TimeService* TimeService::instance()
{
    if(__timeService == nullptr){
        __timeService = new TimeService();
    }
    return __timeService;
}

TimeService::~TimeService()
{

}



void TimeService::slotGetTimeFinish()
{


    qDebug()<<"TimeService::slotGetTimeFinish end";
}

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include "timeservice.h"
#include "systeminfo.h"

QObject *timeService_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
{
    Q_UNUSED(engine)
    Q_UNUSED(scriptEngine)
    return TimeService::instance();
}

QObject *systemInfo_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
{
    Q_UNUSED(engine)
    Q_UNUSED(scriptEngine)
    return SystemInfo::instance();
}

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    QGuiApplication app(argc, argv);

    qmlRegisterSingletonType<TimeService>("CPPService", 1, 0, "TimeService",timeService_provider);
    qmlRegisterSingletonType<SystemInfo>("CPPService", 1, 0, "SystemInfo",systemInfo_provider);//多个C++类可以注册到同一个模块名CPPService
    TimeService::instance();//初始化单例
    SystemInfo::instance();

    QQmlApplicationEngine engine;
    const QUrl url(QStringLiteral("qrc:/main.qml"));
    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
                     &app, [url](QObject *obj, const QUrl &objUrl) {
        if (!obj && url == objUrl)
            QCoreApplication::exit(-1);
    }, Qt::QueuedConnection);
    engine.load(url);

    return app.exec();
}

import QtQuick 2.12
import QtQuick.Window 2.12
import QtQuick.Controls 2.5
import QtQml 2.12
import CPPService 1.0

Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")
    property int nTime: 0
    property double dTime: 0
    property real rTime: 0
    property int nIndex: 0

    Component.onCompleted: {
        strText.text = SystemInfo.currentCpuArchitecture() //调用C++里的函数
    }

    Rectangle{
        id:leftRect
        width: 100
        height: 50
        anchors.top: parent.top
        anchors.left: parent.left
        color: "red"
        MouseArea {
            anchors.fill: parent
            onClicked: {
                var currentDate = new Date()
                nTime = currentDate.getTime()
                dTime = currentDate.getTime()
                rTime = currentDate.getTime()
                var nCount = TimeService.countTimeObject();
                console.log("leftRect===================time=====" + currentDate.getTime());
                console.log("leftRect===================nTime====" + nTime);
                console.log("leftRect===================dTime====" + dTime);
                console.log("leftRect===================rTime====" + rTime);
                console.log("leftRect===================nCount====" + nCount);
                console.log("leftRect===================SystemInfo.getText()====" + SystemInfo.getText());
                var json = TimeService.getTimeObject(1);
                console.log("leftRect===================json====" + json);
                console.log("leftRect===================closeTime====" + json.closeTime);
                console.log("leftRect===================closeStatus====" + json.closeStatus);
            }
        }
    }

    Text {
        id: strText
        text: qsTr("text")
        anchors.left: parent.left
        anchors.top: parent.top
        anchors.topMargin: 50
    }

    Connections {
        target: TimeService   // TimeService类里发出的信号
        onSignalTimeCount: {
            console.log("rightRect===================onSignalTimeCount===nCount=" + nCount);
        }

    }

    Rectangle{
        id:rightRect
        width: 100
        height: 50
        anchors.top: parent.top
        anchors.right: parent.right
        color: "green"
        MouseArea {
            anchors.fill: parent
            onClicked: {
                var currentDate = new Date()
                //传json参数给C++
                nIndex += 1
                var dTime = currentDate.getTime()
                var data = {
                    "closeTime": dTime,
                    "closeStatus": true
                };
                TimeService.setTimeObject(nIndex, data);
                console.log("rightRect===================nIndex====" + nIndex);
                console.log("rightRect===================time====" + currentDate.getTime());

            }
        }
    }
}