--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/src/contacts/qcontactmanager_p.cpp Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,434 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qcontactmanager.h"
+#include "qcontactmanager_p.h"
+#include "qcontactmanagerengine.h"
+#include "qcontactmanagerenginefactory.h"
+
+#include "qcontact_p.h"
+
+#include "qcontactaction.h"
+#include "qcontactactiondescriptor.h"
+#include "qcontactactionfactory.h"
+
+#include <QSharedData>
+#include <QtPlugin>
+#include <QPluginLoader>
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+
+#include <QApplication>
+
+#if defined(Q_OS_SYMBIAN)
+# include <f32file.h>
+#endif
+
+#include "qcontactmemorybackend_p.h"
+#include "qcontactinvalidbackend_p.h"
+
+QTM_BEGIN_NAMESPACE
+
+/* Shared QContactManager stuff here, default engine stuff below */
+QList<QContactActionFactory*> QContactManagerData::m_actionfactories; // list of all factories
+QList<QContactActionDescriptor> QContactManagerData::m_descriptors;
+QHash<QString, QContactManagerEngineFactory*> QContactManagerData::m_engines;
+QContactManagerData::DescriptorHash QContactManagerData::m_descriptormap;
+QHash<QString, int> QContactManagerData::m_vendormap;
+QHash<QString, int> QContactManagerData::m_actionmap;
+
+bool QContactManagerData::m_discovered;
+bool QContactManagerData::m_discoveredStatic;
+QStringList QContactManagerData::m_pluginPaths;
+
+static void qContactsCleanEngines()
+{
+ QContactManagerData::m_discovered = false;
+ QList<QContactManagerEngineFactory*> factories = QContactManagerData::m_engines.values();
+ QList<QContactActionFactory*> actionfactories = QContactManagerData::m_actionfactories;
+
+ for (int i=0; i < factories.count(); i++) {
+ delete factories.at(i);
+ }
+ for(int i=0; i < actionfactories.count(); i++) {
+ delete actionfactories.at(i);
+ }
+ QContactManagerData::m_engines.clear();
+ QContactManagerData::m_actionfactories.clear();
+ QContactManagerData::m_descriptors.clear();
+ QContactManagerData::m_descriptormap.clear();
+ QContactManagerData::m_actionmap.clear();
+ QContactManagerData::m_vendormap.clear();
+}
+
+
+static int parameterValue(const QMap<QString, QString>& parameters, const char* key, int defaultValue)
+{
+ if (parameters.contains(QString::fromAscii(key))) {
+ bool ok;
+ int version = parameters.value(QString::fromAscii(key)).toInt(&ok);
+
+ if (ok)
+ return version;
+ }
+ return defaultValue;
+}
+
+void QContactManagerData::createEngine(const QString& managerName, const QMap<QString, QString>& parameters)
+{
+ m_engine = 0;
+
+ QString builtManagerName = managerName.isEmpty() ? QContactManager::availableManagers().value(0) : managerName;
+ if (builtManagerName == QLatin1String("memory")) {
+ m_engine = QContactMemoryEngine::createMemoryEngine(parameters);
+ } else {
+ int implementationVersion = parameterValue(parameters, QTCONTACTS_IMPLEMENTATION_VERSION_NAME, -1);
+
+ bool found = false;
+ bool loadedDynamic = false;
+
+ /* First check static factories */
+ loadStaticFactories();
+
+ /* See if we got a fast hit */
+ QList<QContactManagerEngineFactory*> factories = m_engines.values(builtManagerName);
+ m_error = QContactManager::NoError;
+
+ while(!found) {
+ foreach (QContactManagerEngineFactory* f, factories) {
+ QList<int> versions = f->supportedImplementationVersions();
+ if (implementationVersion == -1 ||//no given implementation version required
+ versions.isEmpty() || //the manager engine factory does not report any version
+ versions.contains(implementationVersion)) {
+ m_engine = f->engine(parameters, m_error);
+ found = true;
+ break;
+ }
+ }
+
+ // Break if found or if this is the second time through
+ if (loadedDynamic || found)
+ break;
+
+ // otherwise load dynamic factories and reloop
+ loadFactories();
+ factories = m_engines.values(builtManagerName);
+ loadedDynamic = true;
+ }
+
+ // XXX remove this
+ // the engine factory could lie to us, so check the real implementation version
+ if (m_engine && (implementationVersion != -1 && m_engine->managerVersion() != implementationVersion)) {
+ m_error = QContactManager::VersionMismatchError;
+ m_engine = 0;
+ }
+
+ if (!m_engine) {
+ if (m_error == QContactManager::NoError)
+ m_error = QContactManager::DoesNotExistError;
+ m_engine = new QContactInvalidEngine(); // XXX share
+ }
+ }
+}
+
+
+void QContactManagerData::loadStaticFactories()
+{
+ if (!m_discoveredStatic) {
+ m_discoveredStatic = true;
+
+ /* Clean stuff up at the end */
+ qAddPostRoutine(qContactsCleanEngines);
+
+ /* Loop over all the static plugins */
+ QObjectList staticPlugins = QPluginLoader::staticInstances();
+ for (int i=0; i < staticPlugins.count(); i++ ){
+ QContactManagerEngineFactory *f = qobject_cast<QContactManagerEngineFactory*>(staticPlugins.at(i));
+ QContactActionFactory *g = qobject_cast<QContactActionFactory*>(staticPlugins.at(i));
+ if (f) {
+ QString name = f->managerName();
+ qDebug() << "Static: found an engine plugin" << f << "with name" << name;
+ if (name != QLatin1String("memory") && name != QLatin1String("invalid") && !name.isEmpty()) {
+ // we also need to ensure that we haven't already loaded this factory.
+ if (m_engines.keys().contains(name)) {
+ qWarning() << "Static contacts plugin" << name << "has the same name as a currently loaded plugin; ignored";
+ } else {
+ m_engines.insertMulti(name, f);
+ }
+ } else {
+ qWarning() << "Static contacts plugin with reserved name" << name << "ignored";
+ }
+ }
+
+ if (g) {
+ QString name = g->name();
+ qDebug() << "Static: found an action factory" << g << "with name" << name;
+
+ if (m_actionfactories.contains(g)) {
+ qWarning() << "Static contacts plugin" << name << "has the same name as currently loaded plugin; ignored";
+ } else {
+ m_actionfactories.append(g);
+
+ QList<QContactActionDescriptor> actions = g->actionDescriptors();
+ QMap<QContactActionDescriptor, QContactActionFactory*>::iterator it;
+ for (int j = 0; j < actions.size(); j++) {
+ QContactActionDescriptor desc = actions.at(j);
+ m_descriptormap.insert(desc, g);
+ m_descriptors.append(desc);
+ m_actionmap.insertMulti(desc.actionName(), m_descriptors.count() - 1);
+ m_vendormap.insertMulti(desc.vendorName(), m_descriptors.count() - 1);
+ }
+ }
+ }
+ }
+ }
+}
+
+/* Plugin loader */
+void QContactManagerData::loadFactories()
+{
+ // Always do this..
+ loadStaticFactories();
+
+ if (!m_discovered || QApplication::libraryPaths() != m_pluginPaths) {
+ m_discovered = true;
+ m_pluginPaths = QApplication::libraryPaths();
+
+ /* Discover a bunch o plugins */
+ QStringList plugins;
+
+ QStringList paths;
+ QSet<QString> processed;
+
+ paths << QApplication::applicationDirPath() << QApplication::libraryPaths();
+ qDebug() << "Plugin paths:" << paths;
+
+ /* Enumerate our plugin paths */
+ for (int i=0; i < paths.count(); i++) {
+ if (processed.contains(paths.at(i)))
+ continue;
+ processed.insert(paths.at(i));
+ QDir pluginsDir(paths.at(i));
+ if (!pluginsDir.exists())
+ continue;
+
+#if defined(Q_OS_WIN)
+ if (pluginsDir.dirName().toLower() == QLatin1String("debug") || pluginsDir.dirName().toLower() == QLatin1String("release"))
+ pluginsDir.cdUp();
+#elif defined(Q_OS_MAC)
+ if (pluginsDir.dirName() == QLatin1String("MacOS")) {
+ pluginsDir.cdUp();
+ pluginsDir.cdUp();
+ pluginsDir.cdUp();
+ }
+#endif
+
+#if defined(Q_OS_SYMBIAN)
+ // In Symbian, going cdUp() in a c:/private/<uid3>/ will result in *platsec* error at fileserver (requires AllFiles capability)
+ // Also, trying to cd() to a nonexistent directory causes *platsec* error. This does not cause functional harm, but should
+ // nevertheless be changed to use native Symbian methods to avoid unnecessary platsec warnings (as per qpluginloader.cpp).
+ RFs rfs;
+ qt_symbian_throwIfError(rfs.Connect());
+ bool pluginPathFound = false;
+ QStringList directories;
+ directories << QString("plugins/contacts") << QString("contacts") << QString("../plugins/contacts");
+ foreach (const QString& dirName, directories) {
+ QString testDirPath = pluginsDir.path() + "/" + dirName;
+ testDirPath = QDir::cleanPath(testDirPath);
+ // Use native Symbian code to check for directory existence, because checking
+ // for files from under non-existent protected dir like E:/private/<uid> using
+ // QDir::exists causes platform security violations on most apps.
+ QString nativePath = QDir::toNativeSeparators(testDirPath);
+ TPtrC ptr = TPtrC16(static_cast<const TUint16*>(nativePath.utf16()), nativePath.length());
+ TUint attributes;
+ TInt err = rfs.Att(ptr, attributes);
+ if (err == KErrNone) {
+ // yes, the directory exists.
+ pluginsDir.cd(testDirPath);
+ pluginPathFound = true;
+ break;
+ }
+ }
+ rfs.Close();
+ if (pluginPathFound) {
+#else
+ if (pluginsDir.cd(QLatin1String("plugins/contacts")) || pluginsDir.cd(QLatin1String("contacts")) || (pluginsDir.cdUp() && pluginsDir.cd(QLatin1String("plugins/contacts")))) {
+#endif
+ const QStringList& files = pluginsDir.entryList(QDir::Files);
+ qDebug() << "Looking for plugins in" << pluginsDir.path() << files;
+ for (int j=0; j < files.count(); j++) {
+ plugins << pluginsDir.absoluteFilePath(files.at(j));
+ }
+ }
+ }
+
+ /* Now discover the dynamic plugins */
+ for (int i=0; i < plugins.count(); i++) {
+ QPluginLoader qpl(plugins.at(i));
+ QContactManagerEngineFactory *f = qobject_cast<QContactManagerEngineFactory*>(qpl.instance());
+ QContactActionFactory *g = qobject_cast<QContactActionFactory*>(qpl.instance());
+
+ if (f) {
+ QString name = f->managerName();
+ qDebug() << "Dynamic: found an engine plugin" << f << "with name" << name;
+
+ if (name != QLatin1String("memory") && name != QLatin1String("invalid") && !name.isEmpty()) {
+ // we also need to ensure that we haven't already loaded this factory.
+ if (m_engines.keys().contains(name)) {
+ qWarning() << "Contacts plugin" << plugins.at(i) << "has the same name as currently loaded plugin" << name << "; ignored";
+ } else {
+ m_engines.insertMulti(name, f);
+ }
+ } else {
+ qWarning() << "Contacts plugin" << plugins.at(i) << "with reserved name" << name << "ignored";
+ }
+ }
+
+ if (g) {
+ QString name = g->name();
+ qDebug() << "Dynamic: found an action factory" << g << "with name" << name;
+
+ // we also need to ensure that we haven't already loaded this factory.
+ if (m_actionfactories.contains(g)) {
+ qWarning() << "Contacts plugin" << plugins.at(i) << "has the same name as currently loaded plugin" << name << "; ignored";
+ } else {
+ m_actionfactories.append(g);
+
+ QList<QContactActionDescriptor> actions = g->actionDescriptors();
+ QMap<QContactActionDescriptor, QContactActionFactory*>::iterator it;
+ for (int j = 0; j < actions.size(); j++) {
+ const QContactActionDescriptor& desc = actions.at(j);
+ m_descriptormap.insert(desc, g);
+ m_descriptors.append(desc);
+ m_actionmap.insertMulti(desc.actionName(), m_descriptors.count() - 1);
+ m_vendormap.insertMulti(desc.vendorName(), m_descriptors.count() - 1);
+ }
+ }
+ }
+
+ /* Debugging */
+ if (!f && !g) {
+ qDebug() << "Unknown plugin:" << qpl.errorString();
+ if (qpl.instance()) {
+ qDebug() << "[qobject:" << qpl.instance() << "]";
+ }
+ }
+ }
+
+ QStringList engineNames;
+ foreach (QContactManagerEngineFactory* f, m_engines.values()) {
+ QStringList versions;
+ foreach (int v, f->supportedImplementationVersions()) {
+ versions << QString::fromAscii("%1").arg(v);
+ }
+ engineNames << QString::fromAscii("%1[%2]").arg(f->managerName()).arg(versions.join(QString::fromAscii(",")));
+ }
+ qDebug() << "Found engines:" << engineNames;
+ qDebug() << "Found actions:" << m_actionmap.keys();
+ }
+}
+
+QList<QContactActionDescriptor> QContactManagerData::actionDescriptors(const QString& actionName, const QString& vendorName, int implementationVersion)
+{
+ loadFactories();
+
+ bool restrict = false;
+ QSet<int> subset;
+ QList<QContactActionDescriptor> descriptors;
+
+ // Go through our list of descriptors, looking for a match
+ if (!actionName.isEmpty()) {
+ subset = m_actionmap.values(actionName).toSet();
+ restrict = true;
+ }
+
+ if (!vendorName.isEmpty()) {
+ if (restrict)
+ subset &= m_vendormap.values(vendorName).toSet();
+ else
+ subset = m_vendormap.values(vendorName).toSet();
+ restrict = true;
+
+ /* We still have to check versions, since we don't hash that */
+ if (implementationVersion != -1) {
+ QMutableSetIterator<int> it(subset);
+ while(it.hasNext()) {
+ if (m_descriptors.at(it.next()).implementationVersion() != implementationVersion)
+ it.remove();
+ }
+ }
+ }
+
+ if (restrict) {
+ QSetIterator<int> it(subset);
+ while(it.hasNext()) {
+ descriptors << m_descriptors.at(it.next());
+ }
+ } else {
+ /* No restrictions, just iterate over all descriptors and return all actions (!) */
+ descriptors = m_descriptors;
+ }
+
+ return descriptors;
+}
+
+QContactAction* QContactManagerData::action(const QContactActionDescriptor& actionDescriptor)
+{
+ loadFactories();
+ QContactActionFactory* actionFactory = m_descriptormap.value(actionDescriptor, 0);
+ if (actionFactory)
+ return actionFactory->instance(actionDescriptor);
+ return 0;
+}
+
+// trampoline for private classes
+QContactManagerEngine* QContactManagerData::engine(const QContactManager* manager)
+{
+ if (manager)
+ return manager->d->m_engine;
+ return 0;
+}
+
+QTM_END_NAMESPACE
+