diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/server/src/ncdconfigurationmanagerimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/server/src/ncdconfigurationmanagerimpl.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1100 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of CNcdConfigurationManager +* +*/ + + +#include + +#include "ncderrors.h" +#include "ncdconfigurationmanagerimpl.h" +#include "catalogsdebug.h" +#include "catalogscontext.h" +#include "catalogsutils.h" +#include "ncdstoragemanager.h" +#include "ncddatabasestorage.h" +#include "ncdstorage.h" +#include "ncdkeyvaluemap.h" +#include "ncdkeyvaluepair.h" +#include "ncdproviderdefines.h" +#include "ncdstorageitem.h" +#include "ncdserveraddress.h" +#include "ncdconfigurationkeys.h" +#include "ncdutils.h" +#include "catalogsconstants.h" +#include "ncdconfigurationobserver.h" +#include "ncdserverdetailsimpl.h" +#include "ncdproviderutils.h" +#include "ncdgeneralmanager.h" + + +// --------------------------------------------------------------------------- +// CContextConfigurationId +// --------------------------------------------------------------------------- +// + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::CContextConfiguration* + CNcdConfigurationManager::CContextConfiguration::NewLC( + const MCatalogsContext& aContext, + const TDesC& aId ) + { + CContextConfiguration* self = new( ELeave ) CContextConfiguration( + aContext ); + CleanupStack::PushL( self ); + self->ConstructL( aId ); + return self; + } + + +// --------------------------------------------------------------------------- +// FindNewL +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::CContextConfiguration* + CNcdConfigurationManager::CContextConfiguration::FindNewL( + const MCatalogsContext& aContext ) + { + CContextConfiguration* self = new( ELeave ) CContextConfiguration( + aContext ); + return self; + } + + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::CContextConfiguration::CContextConfiguration( + const MCatalogsContext& aContext ) : + iFamilyId( aContext.FamilyId() ), + iId( NULL ), + iConfigurationGeneral( NULL ), + iConfigurationClientInfo( NULL ), + iSsid( NULL ), + iMasterServer( NULL ) + { + } + + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::CContextConfiguration::ConstructL( + const TDesC& aId ) + { + DLTRACEIN(("")); + iId = aId.AllocL(); + iSsid = KNullDesC8().AllocL(); + iConfigurationGeneral = CNcdKeyValueMap::NewL(); + iConfigurationClientInfo = CNcdKeyValueMap::NewL(); + + DLTRACEOUT(("")); + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::CContextConfiguration::~CContextConfiguration() + { + delete iId; + delete iConfigurationGeneral; + delete iConfigurationClientInfo; + delete iSsid; + delete iMasterServer; + iServerDetails.ResetAndDestroy(); + iObservers.Close(); + } + + +// --------------------------------------------------------------------------- +// ServerDetailsL +// --------------------------------------------------------------------------- +// +MNcdServerDetails& + CNcdConfigurationManager::CContextConfiguration::ServerDetailsL( + const TDesC& aServerUri, + const TDesC& aNamespace ) + { + DLTRACEIN(("")); + CNcdServerDetails* details = ServerDetails( aServerUri, aNamespace ); + + if ( !details ) + { + DLTRACE(("Creating new details")); + details = CNcdServerDetails::NewLC( aServerUri, + aNamespace ); + iServerDetails.AppendL( details ); + CleanupStack::Pop( details ); + } + return *details; + } + +// --------------------------------------------------------------------------- +// ServerDetailsL +// --------------------------------------------------------------------------- +// +CNcdServerDetails* + CNcdConfigurationManager::CContextConfiguration::ServerDetails( + const TDesC& aServerUri, + const TDesC& aNamespace ) + { + DLTRACEIN(("")); + for ( TInt i = 0; i < iServerDetails.Count(); ++i ) + { + if ( iServerDetails[i]->ServerUri() == aServerUri && + iServerDetails[i]->Namespace() == aNamespace ) + { + DLTRACEOUT(("Found details")); + return iServerDetails[i]; + } + } + DLTRACEOUT(("Details not found")); + return NULL; + } + +// --------------------------------------------------------------------------- +// ClearServerDetails +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::CContextConfiguration::ClearServerDetails() + { + DLTRACEIN(("")); + iServerDetails.ResetAndDestroy(); + } + +// --------------------------------------------------------------------------- +// Notifies the observers. +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::CContextConfiguration::NotifyObserversL() const + { + DLTRACEIN(("")); + for ( TInt i = 0; i < iObservers.Count(); i++ ) + { + iObservers[i]->ConfigurationChangedL(); + } + } + +// --------------------------------------------------------------------------- +// Adds an observer. +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::CContextConfiguration::AddObserverL( + MNcdConfigurationObserver& aObserver ) + { + DLTRACEIN(("")); + if ( iObservers.Find( &aObserver ) == KErrNotFound ) + { + iObservers.AppendL( &aObserver ); + } + } + +// --------------------------------------------------------------------------- +// Removes an observer. +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::CContextConfiguration::RemoveObserver( + MNcdConfigurationObserver& aObserver ) + { + DLTRACEIN(("")); + TInt index = iObservers.Find( &aObserver ); + if ( index != KErrNotFound ) + { + iObservers.Remove( index ); + } + } + + +// --------------------------------------------------------------------------- +// ExternalizeL +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::CContextConfiguration::ExternalizeL( + RWriteStream& aStream ) + { + DLTRACEIN(("")); + ExternalizeDesL( *iId, aStream ); + ExternalizeDesL( *iSsid, aStream ); + if ( iMasterServer ) + { + DLTRACE(("Externalizing master server address")); + aStream.WriteInt32L( 1 ); + iMasterServer->ExternalizeL( aStream ); + } + else + { + aStream.WriteInt32L( 0 ); + } + + DLTRACE(("Externalizing %d server details", iServerDetails.Count() )); + // Externalize server capabilities. + aStream.WriteInt32L( iServerDetails.Count() ); + for ( TInt i = 0; i < iServerDetails.Count(); i++ ) + { + iServerDetails[i]->ExternalizeL( aStream ); + } + + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// InternalizeL +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::CContextConfiguration::InternalizeL( + RReadStream& aStream ) + { + DLTRACEIN(("")); + InternalizeDesL( iId, aStream ); + InternalizeDesL( iSsid, aStream ); + TInt32 masterServerExists = aStream.ReadInt32L(); + if ( masterServerExists ) + { + DLTRACE(("Internalizing master server address")); + CNcdServerAddress* newServer = CNcdServerAddress::NewL( aStream ); + delete iMasterServer; + iMasterServer = newServer; + } + else + { + delete iMasterServer; + iMasterServer = NULL; + } + + + // Internalize server capabilities. + iServerDetails.ResetAndDestroy(); + TInt32 serverDetailCount = aStream.ReadInt32L(); + + DLTRACE(("Internalizing %d server details", serverDetailCount )); + + iServerDetails.ReserveL( serverDetailCount ); + for ( TInt i = 0; i < serverDetailCount; i++ ) + { + CNcdServerDetails* details = CNcdServerDetails::NewL( aStream ); + TInt err = iServerDetails.Append( details ); + DASSERT( err == KErrNone ); + } + + DLTRACEOUT(("Internalization successful")); + } + + +// --------------------------------------------------------------------------- +// CNcdConfigurationManager +// --------------------------------------------------------------------------- +// + + +// --------------------------------------------------------------------------- +// Creator +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager* CNcdConfigurationManager::NewL( + CNcdGeneralManager& aGeneralManager ) + { + CNcdConfigurationManager* self = new( ELeave ) CNcdConfigurationManager( + aGeneralManager ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::~CNcdConfigurationManager() + { + DLTRACEIN(("")); + iConfigurations.ResetAndDestroy(); + DLTRACEOUT(("")); + } + +// --------------------------------------------------------------------------- +// Adds a new observer +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::AddObserverL( + MNcdConfigurationObserver& aObserver, + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + TInt index = CreateContextConfigurationL( aContext ); + CContextConfiguration* conf = iConfigurations[index]; + conf->AddObserverL( aObserver ); + } + +// --------------------------------------------------------------------------- +// Removes a observer +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::RemoveObserver( + MNcdConfigurationObserver& aObserver ) + { + DLTRACEIN(("")); + for ( TInt i = 0; i < iConfigurations.Count(); i++ ) + { + iConfigurations[i]->RemoveObserver( aObserver ); + } + } + +// --------------------------------------------------------------------------- +// Master server address getter +// --------------------------------------------------------------------------- +// +const TDesC& CNcdConfigurationManager::MasterServerAddressL( + const MCatalogsContext& aContext ) const + { + DLTRACEIN(("")); + + TInt index = FindConfigurationL( aContext ); + + if ( index != KErrNotFound ) + { + // Context has a configuration + const CContextConfiguration& config( *iConfigurations[index] ); + + // See if MSA exists and is valid + if ( config.iMasterServer && config.iMasterServer->IsValid() ) + { + DLINFO(( _L("Using master server address: %S"), + &config.iMasterServer->Address() )); + return config.iMasterServer->Address(); + } + + + // Check if the client has overridden master server address + CNcdKeyValueMap::KeyValueIndex keyIndex = + config.iConfigurationGeneral->KeyExists( + NcdConfigurationKeys::KMasterServer ); + + if ( keyIndex != KErrNotFound && !config.iUseHardcodedMasterServer ) + { + DLINFO(( _L("Using Master Server Address from client: %S"), + &config.iConfigurationGeneral->ValueByIndex( keyIndex ) )); + return config.iConfigurationGeneral->ValueByIndex( keyIndex ); + } + } + + if ( !NcdProviderDefines::KMasterServerUri().Length() ) + { + DLERROR(("No master server URI. Leaving with KNcdErrorNoMasterServerUri")); + User::Leave( KNcdErrorNoMasterServerUri ); + } + + // Use hardcoded MSA + DLTRACEOUT(( _L("Using hardcoded: %S"), + &NcdProviderDefines::KMasterServerUri() )); + return NcdProviderDefines::KMasterServerUri(); + } + + +// --------------------------------------------------------------------------- +// Master server address validity checker +// --------------------------------------------------------------------------- +// +TBool CNcdConfigurationManager::IsMasterServerAddressValidL( + const MCatalogsContext& aContext ) const + { + DLTRACEIN(("")); + + TInt index = FindConfigurationL( aContext ); + + if ( index != KErrNotFound ) + { + + // Context has a configuration + const CContextConfiguration& config( *iConfigurations[index] ); + + // See if MSA exists + if ( config.iMasterServer ) + { + DLTRACE(("Context has set a Master server address")); + return config.iMasterServer->IsValid(); + } + } + + // Other MSA's are always valid + return ETrue; + } + +// --------------------------------------------------------------------------- +// Master server address & validity setter +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::SetMasterServerAddressL( + const MCatalogsContext& aContext, + const TDesC& aAddress, + const TInt64& aValidity ) + { + DLTRACEIN(( _L("address: %S, validity: %d"), &aAddress, aValidity )); + if ( !aAddress.Length() ) + { + User::Leave( KErrArgument ); + } + + + CNcdServerAddress* address = CNcdServerAddress::NewLC( + aAddress, aValidity ); + + SetMasterServerAddressL( aContext, address ); + CleanupStack::Pop( address ); + + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Master server address & validity setter +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::SetMasterServerAddressL( + const MCatalogsContext& aContext, + CNcdServerAddress* aAddress ) + { + DLTRACEIN(("")); + TInt index = CreateContextConfigurationL( aContext ); + CContextConfiguration& config( *iConfigurations[index] ); + + delete config.iMasterServer; + config.iMasterServer = aAddress; + + config.iUseHardcodedMasterServer = EFalse; + + // Save updated master server address + SaveDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, config ); + + config.NotifyObserversL(); + } + + +// --------------------------------------------------------------------------- +// Resets the master server address +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::ResetMasterServerAddressL( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + // Sets the current overriding master server address as invalid + TInt index = FindConfigurationL( aContext ); + if ( index != KErrNotFound ) + { + if ( iConfigurations[index]->iMasterServer ) + { + DLINFO(("Reverting to client-set/hardcoded MasterServer")); + delete iConfigurations[index]->iMasterServer; + iConfigurations[index]->iMasterServer = NULL; + } + else + { + // Check if the client has overridden master server address + CNcdKeyValueMap::KeyValueIndex keyIndex = + iConfigurations[index]->iConfigurationGeneral->KeyExists( + NcdConfigurationKeys::KMasterServer ); + + if ( keyIndex != KErrNotFound ) + { + // Use hardcoded instead of the one set by the client + iConfigurations[index]->iUseHardcodedMasterServer = ETrue; + } + } + iConfigurations[index]->NotifyObserversL(); + } + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Client ID getter +// --------------------------------------------------------------------------- +// +const TDesC& CNcdConfigurationManager::ClientIdL( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + + TInt index = CreateContextConfigurationL( aContext ); + CContextConfiguration& data( *iConfigurations[index] ); + if ( !data.iId->Length() ) + { + DLTRACE(("Trying to load id from db")); + TRAPD( err, + LoadDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, + data ) ); + + if ( err != KErrNone && err != KErrNotFound ) + { + // serious error + User::Leave( err ); + } + + if ( !data.iId->Length() ) + { + // Generate a new client id + HBufC* id = GenerateClientIdLC(); + delete data.iId; + data.iId = id; + CleanupStack::Pop( id ); + + // Save the client id + SaveDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, data ); + } + } + DLTRACEOUT(( _L("Id: %S"), data.iId )); + return *data.iId; + + } + + +// --------------------------------------------------------------------------- +// SSID setter +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::SetSsidL( const MCatalogsContext& aContext, + HBufC8* aSsid ) + { + DLTRACEIN(( "" )); + TInt index = CreateContextConfigurationL( aContext ); + if ( iConfigurations[index]->iSsid ) + { + DLTRACE(( "Deleting old SSID" )); + delete iConfigurations[index]->iSsid; + } + + iConfigurations[index]->iSsid = aSsid; + + // Save updated Ssid + SaveDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, *iConfigurations[index] ); + + DLTRACEOUT(( "" )); + + } + + +// --------------------------------------------------------------------------- +// SSID getter +// --------------------------------------------------------------------------- +// +const TDesC8& CNcdConfigurationManager::SsidL( + const MCatalogsContext& aContext ) + { + // Try to find the configuration from both memory and db + TInt index = CreateContextConfigurationL( aContext ); + if ( index != KErrNotFound && iConfigurations[index]->iSsid ) + { + return *iConfigurations[index]->iSsid; + } + DLERROR(("No SSID set!")); + return KNullDesC8(); + } + + +// --------------------------------------------------------------------------- +// Server details getter +// --------------------------------------------------------------------------- +// +MNcdServerDetails& CNcdConfigurationManager::ServerDetailsL( + const MCatalogsContext& aContext, + const TDesC& aServerUri, + const TDesC& aNamespace ) + { + DLTRACEIN(( _L("ServerURI: %S, Namespace: %S"), &aServerUri, &aNamespace )); + // Get index for the config. A new configuration is created if necessary + TInt index = CreateContextConfigurationL( aContext ); + + // Get server details. New details are created if necessary + return iConfigurations[index]->ServerDetailsL( aServerUri, aNamespace ); + } + + +// --------------------------------------------------------------------------- +// Server details getter +// --------------------------------------------------------------------------- +// +const MNcdServerDetails* CNcdConfigurationManager::ServerDetails( + const MCatalogsContext& aContext, + const TDesC& aServerUri, + const TDesC& aNamespace ) const + { + DLTRACEIN(( _L("ServerURI: %S, Namespace: %S"), &aServerUri, &aNamespace )); + // Get index for the config. + TInt index = KErrNotFound; + + TRAPD( err, index = FindConfigurationL( aContext ) ); + if ( err == KErrNone && index != KErrNotFound ) + { + // Get server details. New details are created if necessary + return iConfigurations[index]->ServerDetails( aServerUri, aNamespace ); + } + DLTRACEOUT(("Details not found or error occured")); + return NULL; + } + + +// --------------------------------------------------------------------------- +// Saves context configuration details to database. +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::SaveConfigurationToDbL( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + + // Get index for the config. + TInt index = FindConfigurationL( aContext ); + if ( index == KErrNotFound ) + { + DLTRACEOUT(("Configuration not found")); + return; + } + + // Get server details. + CContextConfiguration* config = iConfigurations[index]; + + // Save the configuration. + SaveDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, *config ); + } + +// --------------------------------------------------------------------------- +// Clears the server capabilities. +// --------------------------------------------------------------------------- +void CNcdConfigurationManager::ClearServerCapabilitiesL( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + + // Get index for the config. + TInt index = FindConfigurationL( aContext ); + if ( index == KErrNotFound ) + { + return; + } + + // Get the config and clear server details. + CContextConfiguration* config = iConfigurations[index]; + config->ClearServerDetails(); + + // Save the cleared config. + SaveConfigurationToDbL( aContext ); + } + + +// --------------------------------------------------------------------------- +// AddConfigurationL +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::AddConfigurationL( + const MCatalogsContext& aContext, CNcdKeyValuePair* aConfig ) + { + DLTRACEIN(( "" )); + + // Ensure aConfig is deleted if a leave occurs + CleanupStack::PushL( aConfig ); + + // Get index for the config. A new configuration is created if necessary + TInt index = CreateContextConfigurationL( aContext ); + + CNcdKeyValueMap& map( ConfigurationByCategory( index, aConfig->Key() ) ); + + if ( aConfig->Key() == NcdConfigurationKeys::KCapability ) + { + DLTRACE(("Adding a capability")); + if ( map.PairExists( *aConfig ) == KErrNotFound ) + { + map.AddL( aConfig ); + } + else + { + DLTRACE(("Capability already exists")); + CleanupStack::PopAndDestroy( aConfig ); + return; + } + } + else + { + DLTRACE(("Adding something that is not a capability")); + // Replaces the old key if necessary + map.ReplaceL( aConfig ); + + if ( aConfig->Key() == NcdConfigurationKeys::KMasterServer ) + { + // Ensure that the new master server is used instead of hardcoded one + iConfigurations[index]->iUseHardcodedMasterServer = EFalse; + } + } + + CleanupStack::Pop( aConfig ); + + DLTRACEOUT(("" )); + } + + +// --------------------------------------------------------------------------- +// RemoveConfiguration +// --------------------------------------------------------------------------- +// +TInt CNcdConfigurationManager::RemoveConfigurationL( + const MCatalogsContext& aContext, const TDesC& aKey ) + { + DLTRACEIN(("")); + TInt index = FindConfigurationL( aContext ); + if ( index != KErrNotFound ) + { + return ConfigurationByCategory( index, aKey ).Remove( aKey ); + } + return index; + } + + +// --------------------------------------------------------------------------- +// ConfigurationsL +// --------------------------------------------------------------------------- +// +CNcdKeyValueMap* CNcdConfigurationManager::ConfigurationsLC( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + TInt index = FindConfigurationL( aContext ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + DASSERT( iConfigurations[index]->iConfigurationGeneral && + iConfigurations[index]->iConfigurationClientInfo ); + + // Create a new map and append all different configuration categories to + // it + CNcdKeyValueMap* newMap = CNcdKeyValueMap::NewL( + *iConfigurations[index]->iConfigurationGeneral ); + CleanupStack::PushL( newMap ); + + newMap->AppendL( *iConfigurations[index]->iConfigurationClientInfo ); + + DLTRACEOUT(("")); + return newMap; + } + + +// --------------------------------------------------------------------------- +// ConfigurationsL +// --------------------------------------------------------------------------- +// +CNcdKeyValueMap& CNcdConfigurationManager::ConfigurationsL( + const MCatalogsContext& aContext, + TNcdConfigurationCategory aCategory ) + { + TInt index = FindConfigurationL( aContext ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + return ConfigurationByCategory( index, aCategory ); + } + + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CNcdConfigurationManager::CNcdConfigurationManager( + CNcdGeneralManager& aGeneralManager ) : + iGeneralManager( aGeneralManager), + iStorageManager( aGeneralManager.StorageManager() ) + { + } + + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::ConstructL() + { + } + + +// --------------------------------------------------------------------------- +// Generates a new client id +// --------------------------------------------------------------------------- +// +HBufC* CNcdConfigurationManager::GenerateClientIdLC() const + { + DLTRACEIN(("")); +#ifdef USE_OLD_CLIENT_ID_GENERATOR + // Enough for timestamp (64bit) + rand (32bit) + HBufC* id = HBufC::NewLC( NcdProviderDefines::KClientIdMaxLength ); + + TTime now; + now.HomeTime(); + TInt64 int64 = now.Int64(); + + TInt rand = Math::Rand( int64 ); + + TPtr ptr( id->Des() ); + + + ptr.NumFixedWidth( int64 >> 32, EHex, 8 ); + ptr.AppendNumFixedWidth( int64 & 0xffffffff, EHex, 8 ); + ptr.AppendNumFixedWidth( rand, EHex, 8 ); + DLTRACEOUT(( _L("Client ID: %S"), id )); +#else + + + // Enough for timestamp (64bit) + rand (32bit) + HBufC* id = HBufC::NewLC( NcdProviderDefines::KClientIdMaxLength ); + + TTime now; + now.HomeTime(); + TInt64 int64 = now.Int64(); + + + TInt64 freeSpace = FreeDiskSpaceL( CNcdProviderUtils::FileSession(), + EDriveC ) + int64; + + // Use both timestamp and free disk space to get a unique seed + TInt rand = Math::Rand( freeSpace ); + + TPtr ptr( id->Des() ); + + + ptr.NumFixedWidth( int64 >> 32, EHex, 8 ); + ptr.AppendNumFixedWidth( int64 & 0xffffffff, EHex, 8 ); + ptr.AppendNumFixedWidth( rand, EHex, 8 ); + DLTRACEOUT(( _L("Client ID: %S"), id )); + + +#endif + return id; + } + + +// --------------------------------------------------------------------------- +// MatchContexts +// --------------------------------------------------------------------------- +// +TBool CNcdConfigurationManager::MatchContexts( + const CContextConfiguration& aFirst, + const CContextConfiguration& aSecond ) + { + return ( aFirst.iFamilyId == aSecond.iFamilyId ); + } + + +// --------------------------------------------------------------------------- +// FindConfiguration +// --------------------------------------------------------------------------- +// +TInt CNcdConfigurationManager::FindConfigurationL( + const MCatalogsContext& aContext ) const + { + TIdentityRelation match( + CNcdConfigurationManager::MatchContexts ); + + CContextConfiguration* config = CContextConfiguration::FindNewL( aContext ); + + TInt index = iConfigurations.Find( config, match ); + delete config; + return index; + } + + +// --------------------------------------------------------------------------- +// DetermineCategory +// --------------------------------------------------------------------------- +// +MNcdUserConfiguration::TNcdConfigurationCategory + CNcdConfigurationManager::DetermineCategory( + const TDesC& aKey ) const + { + if ( aKey == NcdConfigurationKeys::KMasterServer + || aKey == NcdConfigurationKeys::KMaxStorageSize ) + { + return ENcdConfigurationGeneral; + } + return ENcdConfigurationClientInfo; + } + + +// --------------------------------------------------------------------------- +// ConfigurationByCategory +// --------------------------------------------------------------------------- +// +CNcdKeyValueMap& CNcdConfigurationManager::ConfigurationByCategory( + TInt aIndex, const TDesC& aKey ) + { + TNcdConfigurationCategory category = DetermineCategory( aKey ); + return ConfigurationByCategory( aIndex, category ); + } + +// --------------------------------------------------------------------------- +// ConfigurationByCategory +// --------------------------------------------------------------------------- +// +CNcdKeyValueMap& CNcdConfigurationManager::ConfigurationByCategory( TInt aIndex, + TNcdConfigurationCategory aCategory ) + { + + switch( aCategory ) + { + case ENcdConfigurationGeneral: + { + return *iConfigurations[aIndex]->iConfigurationGeneral; + } + + case ENcdConfigurationClientInfo: + { + return *iConfigurations[aIndex]->iConfigurationClientInfo; + } + default: + { + DASSERT( 0 ); + } + } + + // For the compiler + CNcdKeyValueMap* ignore = NULL; + return *ignore; + } + + + +// --------------------------------------------------------------------------- +// Create context configuration +// --------------------------------------------------------------------------- +// +TInt CNcdConfigurationManager::CreateContextConfigurationL( + const MCatalogsContext& aContext ) + { + DLTRACEIN(("")); + + TInt index = FindConfigurationL( aContext ); + if ( index == KErrNotFound ) + { + + DLTRACE(( "Creating a new configuration for context" )); + + // Create new config + CContextConfiguration* newConfig = + CContextConfiguration::NewLC( aContext, KNullDesC() ); + + iConfigurations.AppendL( newConfig ); + CleanupStack::Pop( newConfig ); + + // Try to load data from database + TRAPD( err, LoadDataL( aContext.FamilyId().Name(), + NcdProviderDefines::ENcdContextData, *newConfig ) ); + + if ( err != KErrNone && err != KErrNotFound ) + { + DLERROR(( "Context configuration loading failed with: %d", err )); + User::Leave( err ); + } + + // update the index + index = iConfigurations.Count() - 1; + } + + DLTRACEOUT(( "index: %d", index )); + return index; + } + + + +// --------------------------------------------------------------------------- +// Saves data +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::SaveDataL( const TDesC& aId, + NcdProviderDefines::TNcdDatabaseDataType aType, + MNcdStorageDataItem& aDataItem ) + { + DLTRACEIN(( _L("Id: %S, type: %d"), &aId, aType )); + MNcdStorage& storage = iStorageManager.ProviderStorageL( + iGeneralManager.FamilyName() ); + + // NOTE: this creates the database if it does not already exist + MNcdDatabaseStorage& database = + storage.DatabaseStorageL( + NcdProviderDefines::KDefaultDatabaseUid ); + + // Get/create the storage item where the data is saved + // Note: database has the ownership of the item + MNcdStorageItem* item = + database.StorageItemL( aId, + aType ); + + + // Save new item to database + item->SetDataItem( &aDataItem ); + item->OpenL(); + + // Calls ExternalizeL for the node + item->WriteDataL(); + + // Save the node to the database. + // The node object implements MNcdStorageDataItem interface. + // So, the externalize function will insert the data to the stream + // that the database handler will save to the database. + item->SaveL(); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Loads data +// --------------------------------------------------------------------------- +// +void CNcdConfigurationManager::LoadDataL( const TDesC& aId, + NcdProviderDefines::TNcdDatabaseDataType aType, + MNcdStorageDataItem& aDataItem ) + { + DLTRACEIN(( _L("Id: %S, type: %d"), &aId, aType )); + MNcdStorage& storage = iStorageManager.ProviderStorageL( + iGeneralManager.FamilyName() ); + + // NOTE: this creates the database if it does not already exist + MNcdDatabaseStorage& database = + storage.DatabaseStorageL( + NcdProviderDefines::KDefaultDatabaseUid ); + + + if( !database.ItemExistsInStorageL( aId, aType ) ) + { + DLINFO(("Item not found")); + User::Leave( KErrNotFound ); + } + + // Get/create the storage item where the data is saved + // Note: database has the ownership of the item + MNcdStorageItem* item = + database.StorageItemL( aId, + aType ); + + item->SetDataItem( &aDataItem ); + item->ReadDataL(); + + DLTRACEOUT(("")); + }