FCL/sf/mw/qtextensions: comparison qtmobility/src/serviceframework/databasemanager.cpp

equal deleted inserted replaced

-:6fbed849b4f4
+:1f895d8a5b2b
 return;
 }
 if (existing == dbPath) {
 ServiceDatabase *db = 0;
 DatabaseManager::DbScope scope;
-if (dbPath == m_manager->m_userDb->databasePath()) {
+if (m_manager->m_userDb && dbPath == m_manager->m_userDb->databasePath()) {
 db = m_manager->m_userDb;
 scope = DatabaseManager::UserOnlyScope;
 } else if (dbPath == m_manager->m_systemDb->databasePath()) {
 db = m_manager->m_systemDb;
 scope = DatabaseManager::SystemScope;
 }
 }
 void DatabaseFileWatcher::databaseChanged(const QString &path)
 {
-if (path == m_manager->m_userDb->databasePath())
+if (m_manager->m_userDb && path == m_manager->m_userDb->databasePath())
 notifyChanges(m_manager->m_userDb, DatabaseManager::UserScope);
 else if (path == m_manager->m_systemDb->databasePath())
 notifyChanges(m_manager->m_systemDb, DatabaseManager::SystemScope);
 // if database was deleted, the path may have been dropped
 m_watcher->addPath(path);
 }
 void DatabaseFileWatcher::notifyChanges(ServiceDatabase *database, DatabaseManager::DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = DatabaseManager::SystemScope;
+#endif
 QString dbPath = database->databasePath();
 if (!QFile::exists(dbPath)) {
 m_knownServices.remove(dbPath);
 restartDirMonitoring(dbPath, QString());
 return;
 /*
 Constructor
 */
 DatabaseManager::DatabaseManager()
-: m_userDb(new ServiceDatabase),
+: m_userDb(NULL),
 m_systemDb(new ServiceDatabase),
 m_fileWatcher(0),
 m_hasAccessedUserDb(false),
 m_alreadyWarnedOpenError(false)
 {
-initDbPath(UserScope);
+#ifndef Q_OS_SYMBIAN
+m_userDb = new ServiceDatabase;
+initDbPath(UserScope);
+#endif
 initDbPath(SystemScope);
 }
 /*
 Destructor
 or m_systemDb, but does not open any
 database connections
 */
 void DatabaseManager::initDbPath(DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 QSettings::Scope settingsScope;
 QString dbIdentifier;
 ServiceDatabase *db;
 if (scope == SystemScope) {
 settingsScope = QSettings::SystemScope;
 settingsScope = QSettings::UserScope;
 dbIdentifier = "_user";
 db = m_userDb;
 }
-QSettings settings(QSettings::IniFormat, settingsScope,
+#ifdef Q_OS_SYMBIAN
-QLatin1String("Nokia"), QLatin1String("QtServiceFramework"));
+QDir dir(QDir::toNativeSeparators("C:\\Data\\temp\\QtServiceFW"));
-QFileInfo fi(settings.fileName());
+#else
-QDir dir = fi.dir();
+QSettings settings(QSettings::IniFormat, settingsScope,
+QLatin1String("Nokia"), QLatin1String("QtServiceFramework"));
+QFileInfo fi(settings.fileName());
+QDir dir = fi.dir();
+#endif
 QString qtVersion(qVersion());
 qtVersion = qtVersion.left(qtVersion.size() -2); //strip off patch version
 QString dbName = QString("QtServiceFramework_") + qtVersion + dbIdentifier + QLatin1String(".db");
 db->setDatabasePath(dir.path() + QDir::separator() + dbName);
 }
 Returns true if the operation succeeded and false otherwise.
 The last error is set when this function is called.
 */
 bool DatabaseManager::registerService(ServiceMetaDataResults &service, DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 if (scope == DatabaseManager::SystemScope) {
 if(!openDb(DatabaseManager::SystemScope)) {
 return false;
 }  else {
 if (!m_systemDb->registerService(service)) {
 Returns true if the operation succeeded, false otherwise.
 The last error is set when this function is called.
 */
 bool DatabaseManager::unregisterService(const QString &serviceName, DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 if(scope == DatabaseManager::SystemScope) {
 if (!openDb(DatabaseManager::SystemScope))
 return false;
 else {
 if (!m_systemDb->unregisterService(serviceName)) {
 }
 }
 }
 /*
+Removes the initialization specific information of \serviceName from the database
+corresponding to a \scope.
+Returns true if teh operation succeeded, false otherwise.
+The last error is set when this function is called.
+*/
+bool DatabaseManager::serviceInitialized(const QString &serviceName, DbScope scope)
+{
+ServiceDatabase *db = (scope == DatabaseManager::SystemScope) ? m_systemDb : m_userDb;
+if (!openDb(scope)) {
+return false;
+} else {
+if (!db->serviceInitialized(serviceName)) {
+m_lastError = db->lastError();
+return false;
+} else {
+m_lastError.setError(DBError::NoError);
+return true;
+}
+}
+}
+/*
 Retrieves a list of interface descriptors that fulfill the constraints specified
 by \a filter at a given \a scope.
 The last error is set when this function is called.
 */
 QList<QServiceInterfaceDescriptor>  DatabaseManager::getInterfaces(const QServiceFilter &filter, DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+QService::Scope requestedScope;
+if (scope == UserScope) {
+requestedScope = QService::UserScope;
+} else {
+requestedScope = QService::SystemScope;
+}
+scope = SystemScope;
+#endif
 QList<QServiceInterfaceDescriptor> descriptors;
 int userDescriptorCount = 0;
 if (scope == UserScope) {
 if (!openDb(UserScope))
 m_lastError = m_systemDb->lastError();
 return descriptors;
 }
 for (int i = userDescriptorCount; i < descriptors.count(); ++i) {
-descriptors[i].d->scope = QService::SystemScope;
+#ifdef Q_OS_SYMBIAN
+descriptors[i].d->scope = requestedScope;
+#else
+descriptors[i].d->scope = QService::SystemScope;
+#endif
 }
 } else {
 if ( scope == SystemScope) {
 //openDb() should already have handled lastError
 descriptors.clear();
 The last error is set when this function is called.
 */
 QStringList DatabaseManager::getServiceNames(const QString &interfaceName, DatabaseManager::DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 QStringList serviceNames;
 if (scope == UserScope || scope == UserOnlyScope) {
 if(!openDb(DatabaseManager::UserScope))
 return serviceNames;
 serviceNames = m_userDb->getServiceNames(interfaceName);
 The last error is set when this function is called.
 */
 QServiceInterfaceDescriptor DatabaseManager::interfaceDefault(const QString &interfaceName, DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+QService::Scope requestedScope;
+if (scope == UserScope) {
+requestedScope = QService::UserScope;
+} else {
+requestedScope = QService::SystemScope;
+}
+scope = SystemScope;
+#endif
 QServiceInterfaceDescriptor descriptor;
 if (scope == UserScope) {
 if (!openDb(UserScope))
 return QServiceInterfaceDescriptor();
 QString interfaceID;
 //or because we're specifically only querying at system scope
 if (!openDb(SystemScope)) {
 if (scope == SystemScope) {
 m_lastError = m_systemDb->lastError();
 return QServiceInterfaceDescriptor();
-} else if (scope == UserScope && m_userDb->lastError().code() == DBError::NotFound) {
+} else if (scope == UserScope && m_userDb && m_userDb->lastError().code() == DBError::NotFound) {
 m_lastError = m_userDb->lastError();
 return QServiceInterfaceDescriptor();
 }
 } else {
 descriptor = m_systemDb->interfaceDefault(interfaceName);
 if (m_systemDb->lastError().code() == DBError::NoError) {
-descriptor.d->scope = QService::SystemScope;
+#ifdef Q_OS_SYMBIAN
+descriptor.d->scope = requestedScope;
+#else
+descriptor.d->scope = QService::SystemScope;
+#endif
 return descriptor;
 } else if (m_systemDb->lastError().code() == DBError::NotFound) {
 m_lastError = m_systemDb->lastError();
 return QServiceInterfaceDescriptor();
 } else {
 Returns true if the operation succeeded, false otherwise.
 The last error is set when this function is called.
 */
 bool DatabaseManager::setInterfaceDefault(const QServiceInterfaceDescriptor &descriptor, DbScope scope)
 {
-if (scope == UserScope) {
+#ifdef Q_OS_SYMBIAN
-if (!openDb(UserScope))
+Q_UNUSED(scope);
+if (!openDb(SystemScope)) {
 return false;
-if (descriptor.scope() == QService::UserScope) { //if a user scope descriptor, just set it in the user db
+} else {
-if(m_userDb->setInterfaceDefault(descriptor)) {
+if (m_systemDb->setInterfaceDefault(descriptor)) {
 m_lastError.setError(DBError::NoError);
 return true;
 } else {
-m_lastError = m_userDb->lastError();
+m_lastError = m_systemDb->lastError();
 return false;
 }
-} else { //otherwise we need to get the interfaceID from the system db and set this
+}
-//as an external default interface ID in the user db
+#else
-if (!openDb(SystemScope))
+if (scope == UserScope) {
+if (!openDb(UserScope))
 return false;
+if (descriptor.scope() == QService::UserScope) { //if a user scope descriptor, just set it in the user db
-QString interfaceDescriptorID = m_systemDb->getInterfaceID(descriptor);
+if(m_userDb->setInterfaceDefault(descriptor)) {
-if (m_systemDb->lastError().code() == DBError::NoError) {
-if(m_userDb->setInterfaceDefault(descriptor, interfaceDescriptorID)) {
 m_lastError.setError(DBError::NoError);
 return true;
 } else {
 m_lastError = m_userDb->lastError();
 return false;
 }
-} else {
+} else { //otherwise we need to get the interfaceID from the system db and set this
-m_lastError = m_systemDb->lastError();
+//as an external default interface ID in the user db
-return false;
+if (!openDb(SystemScope))
-}
+return false;
-}
-} else {  //scope == SystemScope
+QString interfaceDescriptorID = m_systemDb->getInterfaceID(descriptor);
-if (descriptor.scope() == QService::UserScope) {
+if (m_systemDb->lastError().code() == DBError::NoError) {
-QString errorText("Cannot set default service at system scope with a user scope "
+if(m_userDb->setInterfaceDefault(descriptor, interfaceDescriptorID)) {
-"interface descriptor");
+m_lastError.setError(DBError::NoError);
-m_lastError.setError(DBError::InvalidDescriptorScope, errorText);
+return true;
-return false;
+} else {
-} else {
+m_lastError = m_userDb->lastError();
-if (!openDb(SystemScope)) {
+return false;
-return false;
+}
-} else {
-if (m_systemDb->setInterfaceDefault(descriptor)) {
-m_lastError.setError(DBError::NoError);
-return true;
 } else {
 m_lastError = m_systemDb->lastError();
 return false;
 }
 }
-}
+} else {  //scope == SystemScope
-}
+if (descriptor.scope() == QService::UserScope) {
+QString errorText("Cannot set default service at system scope with a user scope "
+"interface descriptor");
+m_lastError.setError(DBError::InvalidDescriptorScope, errorText);
+return false;
+} else {
+if (!openDb(SystemScope)) {
+return false;
+} else {
+if (m_systemDb->setInterfaceDefault(descriptor)) {
+m_lastError.setError(DBError::NoError);
+return true;
+} else {
+m_lastError = m_systemDb->lastError();
+return false;
+}
+}
+}
+}
+#endif
 }
 /*
 Opens a database connection with the database at a specific \a scope.
 The last error is set when this function is called.
 */
 bool DatabaseManager::openDb(DbScope scope)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 if (scope == SystemScope && m_systemDb->isOpen() && !QFile::exists(m_systemDb->databasePath())) {
 delete m_systemDb;
 m_systemDb = new ServiceDatabase;
 initDbPath(SystemScope);
 m_alreadyWarnedOpenError = false;
 }
 //if we are opening the system database while the user database is open,
 //cleanup and reset any old external defaults
 //from the user scope database
-if (scope == SystemScope && m_userDb->isOpen()) {
+if (scope == SystemScope && m_userDb && m_userDb->isOpen()) {
 QList<QPair<QString,QString> > externalDefaultsInfo;
 externalDefaultsInfo = m_userDb->externalDefaultsInfo();
 QServiceInterfaceDescriptor descriptor;
 QPair<QString,QString> defaultInfo;
 Sets whether change notifications for added and removed services are
 \a enabled or not at a given \a scope.
 */
 void DatabaseManager::setChangeNotificationsEnabled(DbScope scope, bool enabled)
 {
+#ifdef Q_OS_SYMBIAN
+scope = SystemScope;
+#endif
 if (!m_fileWatcher) m_fileWatcher = new
 DatabaseFileWatcher(this); m_fileWatcher->setEnabled(scope == SystemScope ?
 m_systemDb : m_userDb, enabled);
 }

changeset 15	1f895d8a5b2b
parent 11	06b8e2af4411