C++ QServiceManager类代码示例

ActivityTsModel::ActivityTsModel(QObject *parent) : 
QObject(parent),
mMonitor(0),
mAfManager(0) , 
mMaxItems(10)
{
    {
        QServiceManager serviceManager;
        mAfManager = serviceManager.loadInterface(KActivityManager);
        if (mAfManager) {
            mAfManager->setParent(this);
        } else {
            throw std::runtime_error("Cannot create critical com.nokia.qt.activities.ActivityManager service");
        }
    }
    
    {
        XQSettingsManager crManager;
        QVariant itemsNumberVariant = crManager.readItemValue(XQCentralRepositorySettingsKey(KTsDeviceDialogUid, KItemsLimit), XQSettingsManager::TypeInt);
        if (!itemsNumberVariant.isNull()) {
            int number = itemsNumberVariant.toInt();
            if (number > 0) {
                mMaxItems = number;
            }
        }
    }
    
    connect(mAfManager, SIGNAL(dataChanged()), SLOT(getActivities()));
    connect(mAfManager, SIGNAL(thumbnailReady(QPixmap,void*)), SLOT(convertScreenshotToThumbnail(QPixmap,void*)));
    
    getActivities();
}

QTM_USE_NAMESPACE

void unregisterExampleService()
{
    QServiceManager m;
    m.removeService("LandlineDialer");
    m.removeService("VoipDialer");
}

void ServiceBrowser::reloadInterfaceImplementationsList()
{
    QString serviceName;
    if (servicesListWidget->currentItem()
            && servicesListWidget->currentItem() != showAllServicesItem) {
        serviceName = servicesListWidget->currentItem()->text();
        interfacesGroup->setTitle(tr("Interfaces implemented by %1").arg(serviceName));
    } else {
        interfacesGroup->setTitle(tr("All interface implementations"));
    }

    QServiceManager *manager = serviceManager;
    if (serviceName.endsWith(" (system)")) {
        serviceName.chop(9);
        manager = systemManager;
    }

    QList<QServiceInterfaceDescriptor> descriptors = manager->findInterfaces(serviceName);

    attributesListWidget->clear();
    interfacesListWidget->clear();
    for (int i=0; i<descriptors.count(); i++) {
        if (descriptors[i].scope() != manager->scope() && !serviceName.isEmpty())
            continue;

        QString text = QString("%1 %2.%3")
                .arg(descriptors[i].interfaceName())
                .arg(descriptors[i].majorVersion())
                .arg(descriptors[i].minorVersion());

        QServiceInterfaceDescriptor defaultInterfaceImpl 
            = manager->interfaceDefault(descriptors[i].interfaceName());
        
        if (serviceName.isEmpty()) {
            text += " (" + descriptors[i].serviceName() + ")";
            
            if (descriptors[i].scope() == QService::SystemScope) {
                text += tr(" (system");
                defaultInterfaceImpl = systemManager->interfaceDefault(descriptors[i].interfaceName());
                if (descriptors[i] == defaultInterfaceImpl)
                    text += tr(" default)");
                else
                    text += ")";
                defaultInterfaceImpl = QServiceInterfaceDescriptor();
            }
        }
                
        if (descriptors[i] == defaultInterfaceImpl)
            text += tr(" (default)");

        QListWidgetItem *item = new QListWidgetItem(text);
        item->setData(Qt::UserRole, qVariantFromValue(descriptors[i]));
        interfacesListWidget->addItem(item);
    }

    defaultInterfaceButton->setEnabled(false);
}

void registerExampleService()
{
    unregisterExampleService();

    QServiceManager m;
    QStringList exampleXmlFiles;
    exampleXmlFiles << "landlinedialerservice.xml" << "voipdialerservice.xml" << "remotedialerservice.xml";
    foreach (const QString &fileName, exampleXmlFiles) {
        const QString path = QCoreApplication::applicationDirPath() + "/xmldata/" + fileName;
        m.addService(path);
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QServiceManager s;

    if (QFile::exists(xml)) {
        s.removeService("calendarwidgetplugin");
        s.addService(xml);
    } else {
        s.removeService("calendarwidgetplugin");
    }
}

/*!
    Adds widget \a widgetUri utilizing service interface and invokeMethod call
*/
int HsBookmarkPublishClient::addWidget(QString Title, QString Url)
{   
    // find interface IHomeScreenClient from service hshomescreenclientplugin 
    QServiceManager manager;
    QServiceFilter filter("com.nokia.symbian.IHomeScreenClient");
    filter.setServiceName("hshomescreenclientplugin");
    QList<QServiceInterfaceDescriptor> interfaces = manager.findInterfaces(filter);
    QVariantHash params;
    QString iconFileName;
    params["bookmarkTitle"] = Title;
    params["bookmarkUrl"] = Url;
    params["faviconPath"] = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsString("DataBaseDirectory");

    if(interfaces.isEmpty()) {
        QServiceManager::Error error = manager.error();
        return FAILURE;
    }
    
    // Retrieve the favicon and check its exsistance
    QIcon icon = QWebSettings::iconForUrl(Url);
    if (!icon.isNull())
        iconFileName = getIconFileName(Url);
        
    params["faviconFileName"] = iconFileName;
    
    saveFavicon(Url, iconFileName);
    
    QObject* service = manager.loadInterface(interfaces.first());

    // access service's addWidget function
    bool retVal = false;
    bool ret = QMetaObject::invokeMethod( 
        service, 
        "addWidget",
        Qt::DirectConnection,
        Q_RETURN_ARG(bool, retVal),
        Q_ARG(QString,mWidgetUri),
        Q_ARG(QVariantHash,params));   
        
    if(!ret){
        // invokeMethod returned error
        return FAILURE;
    }
    if(!retVal){
        // addWidget returned error
        return FAILURE;
    }
    
    return SUCCESS;
}

QTM_USE_NAMESPACE

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QServiceManager manager;

    if (QFile::exists("c:/private/2002DD16/import/nmregister.xml")) {
        manager.removeService("nmregister");
        manager.addService("c:/private/2002DD16/import/nmregister.xml");
    } else {
        manager.removeService("nmregister");
    }  
}

tst_QContactActions::~tst_QContactActions()
{
    QString path = QApplication::applicationDirPath() + "/dummyplugin/plugins";
    QApplication::removeLibraryPath(path);

    // clean up any actions/services.
    QServiceManager sm;
    QStringList allServices = sm.findServices();
    foreach(const QString& serv, allServices) {
        if (serv.startsWith("tst_qcontact")) {
            if (!sm.removeService(serv)) {
                qDebug() << " tst_qca: ctor: cleaning up test service" << serv << "failed:" << sm.error();
            }
        }
    }
}

FtuFirstTimeUse::FtuFirstTimeUse(QObject* aParent) : 
    QObject(aParent),
    mRuntime(NULL)
{  
    QDEBUG("FTU::FtuFirstTimeUse::FtuFirstTimeUse");
    
    registerServicePlugins();

    QServiceManager manager;
    QServiceFilter filter(ftuRuntimeUri);
    QList<QServiceInterfaceDescriptor> interfaces = manager.findInterfaces(
                                                                    filter);
    
    QDEBUG("ftu: found " << interfaces.count() 
             << " instances of runtime";)
    
    if(interfaces.count() > 0){

void ServiceBrowser::setDefaultInterfaceImplementation()
{
    QListWidgetItem *item = interfacesListWidget->currentItem();
    if (!item)
        return;

    QServiceInterfaceDescriptor descriptor = item->data(Qt::UserRole).value<QServiceInterfaceDescriptor>();
    if (descriptor.isValid()) {
        QServiceManager *manager = serviceManager;

        if (descriptor.scope() == QService::SystemScope)
            manager = systemManager;

        if (manager->setInterfaceDefault(descriptor)) {
            int currentIndex = interfacesListWidget->row(item);
            reloadInterfaceImplementationsList();
            interfacesListWidget->setCurrentRow(currentIndex);
        } else {
            qWarning() << "Unable to set default service for interface:" 
                    << descriptor.interfaceName();
        }
    }
}

void ToDoTool::init()
{
    bool ok;
    QString interfaceName = QInputDialog::getText(this, tr("ToDoTool"), tr("Specify Notes Manager interface:"),
                                                  QLineEdit::Normal, "com.nokia.qt.examples.NotesManager", &ok);
    if (ok) {
        QServiceInterfaceDescriptor desc = serviceManager->interfaceDefault(interfaceName);

        if (desc.isValid()) {
            QServiceManager mgr;
            notesManager = mgr.loadInterface(desc);

            if (notesManager)
                notesManager->setParent(this);
            
            bool connect;
            QMetaObject::invokeMethod(notesManager, "init", Q_RETURN_ARG(bool, connect));
            if (connect) {
                currentNote = 1;
                searchWord = "";    
                refreshList();

                addButton->setEnabled(true);
                deleteButton->setEnabled(true);
                searchButton->setEnabled(true);
                nextButton->setEnabled(true);
                prevButton->setEnabled(true);

                QObject::connect(notesManager, SIGNAL(soundAlarm(QDateTime)), 
                        this, SLOT(soundAlarm(QDateTime))); 
            } else {
                QMessageBox msgBox;
                msgBox.setWindowTitle(tr("ToDoTool"));
                msgBox.setText("Unable to access notes manager database\n in current or home directory");
                msgBox.exec();
            }
        } else {

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QServiceManager s;

	if (QFile::exists(filemanagerxml)) {
		s.addService(filemanagerxml);
	} else {
		s.removeService("FileManagerService");
	}
	
	if (QFile::exists(bluetoothxml)) {
		s.addService(bluetoothxml);
	} else {
		s.removeService("BluetoothTransferService");
	}

    if (QFile::exists(notemanagerxml)) {
		s.addService(notemanagerxml);
	} else {
		s.removeService("NotesManagerService");
	}
}