diff -r 000000000000 -r b497e44ab2fc omaprovisioning/provisioning/ProvisioningEngine/Src/CWPMultiContextManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omaprovisioning/provisioning/ProvisioningEngine/Src/CWPMultiContextManager.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,847 @@ +/* +* Copyright (c) 2002 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: Multiple context manager. +* +*/ + + +// INCLUDE FILES +#include "CWPMultiContextManager.h" +#include +#include +#include +#include +#include "MWPContextObserver.h" +#include "ProvisioningDebug.h" + +// CONSTANTS +_LIT( KDbFullName, "C:\\system\\data\\wpcontext.db" ); +_LIT( KDbNameDBMS, "c:wpcontext.db" ); +_LIT( KDbTableNames, "A" ); +_LIT( KDbIndexNamesUid, "AA" ); +_LIT( KDbIndexNamesTPS, "AB" ); +_LIT( KDbColumnNamesId, "AC" ); +_LIT( KDbColumnNamesName, "AD" ); +_LIT( KDbColumnNamesTPS, "AE" ); +_LIT( KDbTableProxies, "B" ); +_LIT( KDbIndexProxiesContextId, "BA" ); +_LIT( KDbColumnProxiesContextId, "BB" ); +_LIT( KDbColumnProxiesProxy, "BC" ); +const TInt KProxiesGranularity = 3; +const TInt KNewContextSizeEstimate = 128; + +#ifdef SYMBIAN_SECURE_DBMS +_LIT(KWPSecureDBMSFormatSpecifier, "SECURE[101F84D6]"); +#endif + +const TInt KWPDBMSFileValue = 0x101F84D6; +const TUid KWPDBMSFileUid = { KWPDBMSFileValue }; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CWPMultiContextManager +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CWPMultiContextManager::CWPMultiContextManager() +: CActive( EPriorityStandard ) + { + CActiveScheduler::Add( this ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::ConstructL() + { + User::LeaveIfError( iDbSession.Connect() ); + OpenDatabaseL(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CWPMultiContextManager* CWPMultiContextManager::NewL() + { + CWPMultiContextManager* self = NewLC(); + CleanupStack::Pop(); + + return self; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CWPMultiContextManager* CWPMultiContextManager::NewLC() + { + CWPMultiContextManager* self = new( ELeave ) CWPMultiContextManager; + + CleanupStack::PushL( self ); + self->ConstructL(); + + return self; + } + +// Destructor +CWPMultiContextManager::~CWPMultiContextManager() + { + Cancel(); + + iNotifier.Close(); + iDataBase.Close(); + iDbSession.Close(); + iObservers.Close(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::OpenDatabaseL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::OpenDatabaseL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenDatabaseL" ) ); + TInt result = KErrNone; + +#ifdef SYMBIAN_SECURE_DBMS + result = iDataBase.Open( iDbSession, KDbNameDBMS, KWPSecureDBMSFormatSpecifier ); + FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 1 result (%d)"), result)); +#else + iDataBasePath.Zero(); + iDataBasePath.Append( KDbFullName ); + result = iDataBase.Open( iDbSession, iDataBasePath ); + FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 1 result (%d)"), result)); + +#endif + if( result == KErrNotFound || result == KErrArgument ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenDatabaseL close and recreate" ) ); + iDataBase.Close(); + CreateDatabaseL(); + #ifdef SYMBIAN_SECURE_DBMS + result = iDataBase.Open( iDbSession, KDbNameDBMS, KWPSecureDBMSFormatSpecifier ); + #else + result = iDataBase.Open( iDbSession, iDataBasePath ); + #endif + FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 2 result (%d)"), result)); + } + User::LeaveIfError( result ); + CheckDatabaseL(); + + User::LeaveIfError( iNotifier.Open( iDataBase ) ); + IssueRequest(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CreateDatabaseL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CreateDatabaseL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDatabaseL" ) ); + + const TName WPContextDbmsTypeName = + #ifdef SYMBIAN_SECURE_DBMS + KWPSecureDBMSFormatSpecifier(); + #else + KWPDBMSFileUid.Name(); + #endif + + RDbNamedDatabase db; +#ifdef SYMBIAN_SECURE_DBMS + TInt retval = iDbSession.DeleteDatabase( KDbNameDBMS, KWPDBMSFileUid ); + + retval = iDataBase.Create( iDbSession, KDbNameDBMS, WPContextDbmsTypeName ); + FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::CreateDatabaseL: retval (%d)"), retval)); + CleanupClosePushL( iDataBase ); + + CreateNamesTableL( iDataBase ); + CreateProxiesTableL( iDataBase ); + CreateDataTableL( iDataBase ); + + CleanupStack::PopAndDestroy(); // iDataBase + +#else + RFs fs; + User::LeaveIfError( fs.Connect() ); + CleanupClosePushL( fs ); + + if( SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KEmptyDbSizeEstimate ) ) + { + User::Leave( KErrDiskFull ); + } + iDataBasePath.Zero(); + iDataBasePath.Append( KDbFullName ); + // Make sure the database file does not exist + fs.Delete( iDataBasePath ); + CleanupStack::PushL( TCleanupItem( CleanupDeleteDb, &fs ) ); + + User::LeaveIfError( db.Create( fs, iDataBasePath ) ); + + CleanupClosePushL( db ); + + CreateNamesTableL( db ); + CreateProxiesTableL( db ); + CreateDataTableL( db ); + + CleanupStack::PopAndDestroy(); // db + CleanupStack::Pop(); // deleteDb + CleanupStack::PopAndDestroy(); // fs +#endif + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDatabaseL done:" ) ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CheckDatabaseL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CheckDatabaseL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL" ) ); + if( iDataBase.IsDamaged() ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL damaged" ) ); + User::LeaveIfError( iDataBase.Recover() ); + } + FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL OK" ) ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CreateNamesTableL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CreateNamesTableL( RDbDatabase& aDb ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateNamesTableL" ) ); + + // Create the actual table + CDbColSet* colset = CDbColSet::NewLC(); + TDbCol idCol( KDbColumnNamesId, EDbColUint32 ); + idCol.iAttributes = TDbCol::EAutoIncrement; + colset->AddL( idCol ); + TDbCol nameCol( KDbColumnNamesName, EDbColText16 ); + colset->AddL( nameCol ); + TDbCol tpsCol( KDbColumnNamesTPS, EDbColText16 ); + tpsCol.iAttributes = TDbCol::ENotNull; + colset->AddL( tpsCol ); + User::LeaveIfError( aDb.CreateTable( KDbTableNames, *colset ) ); + CleanupStack::PopAndDestroy(); // colset + + // Index for searching by UID + CDbKey* key = CDbKey::NewLC(); + TDbKeyCol idkeyCol( KDbColumnNamesId ); + key->AddL( idkeyCol ); + User::LeaveIfError( + aDb.CreateIndex( KDbIndexNamesUid, KDbTableNames, *key ) ); + CleanupStack::PopAndDestroy(); // key + + // Index for searching by TPS + key = CDbKey::NewLC(); + TDbKeyCol tpskeyCol( KDbColumnNamesTPS ); + key->AddL( tpskeyCol ); + User::LeaveIfError( + aDb.CreateIndex( KDbIndexNamesTPS, KDbTableNames, *key ) ); + CleanupStack::PopAndDestroy(); // key + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CreateProxiesTableL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CreateProxiesTableL( RDbDatabase& aDb ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateProxiesTableL" ) ); + + // Create the actual table + CDbColSet* colset = CDbColSet::NewLC(); + TDbCol contextIdCol( KDbColumnProxiesContextId, EDbColUint32 ); + contextIdCol.iAttributes = TDbCol::ENotNull; + colset->AddL( contextIdCol ); + TDbCol proxyCol( KDbColumnProxiesProxy, EDbColText ); + proxyCol.iAttributes = TDbCol::ENotNull; + colset->AddL( proxyCol ); + User::LeaveIfError( aDb.CreateTable( KDbTableProxies, *colset ) ); + CleanupStack::PopAndDestroy(); // colset + + // Index for searching by context UID + CDbKey* key = CDbKey::NewLC(); + TDbKeyCol contextkeyCol( KDbColumnProxiesContextId ); + key->AddL( contextkeyCol ); + User::LeaveIfError( + aDb.CreateIndex( KDbIndexProxiesContextId, KDbTableProxies, *key ) ); + CleanupStack::PopAndDestroy(); // key + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CreateDataTableL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CreateDataTableL( RDbDatabase& aDb ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDataTableL" ) ); + + // Create the actual table + CDbColSet* colset = CDbColSet::NewLC(); + TDbCol contextIdCol( KDbColumnDataContextId, EDbColUint32 ); + contextIdCol.iAttributes = TDbCol::ENotNull; + colset->AddL( contextIdCol ); + TDbCol adapterIdCol( KDbColumnDataAdapterId, EDbColUint32 ); + adapterIdCol.iAttributes = TDbCol::ENotNull; + colset->AddL( adapterIdCol ); + TDbCol saveDataCol( KDbColumnDataSaveData, EDbColBinary ); + colset->AddL( saveDataCol ); + User::LeaveIfError( aDb.CreateTable( KDbTableData, *colset ) ); + CleanupStack::PopAndDestroy(); // colset + + // Index for searching by context UID and adapter UID + CDbKey* key = CDbKey::NewLC(); + TDbKeyCol contextkeyCol( KDbColumnDataContextId ); + key->AddL( contextkeyCol ); + TDbKeyCol adapterkeyCol( KDbColumnDataAdapterId ); + key->AddL( adapterkeyCol ); + User::LeaveIfError( + aDb.CreateIndex( KDbIndexDataContextId, KDbTableData, *key ) ); + CleanupStack::PopAndDestroy(); // key + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CreateContextL +// ----------------------------------------------------------------------------- +// +TUint32 CWPMultiContextManager::CreateContextL( const TDesC& aName, + const TDesC& aTPS, + const MDesCArray& aProxies ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateContextL" ) ); + + CheckDatabaseL(); + + // Check if a context has been created for the particular TPS + if( ContextExistsL( aTPS ) ) + { + User::Leave( KErrAlreadyExists ); + } + + if( SysUtil::FFSSpaceBelowCriticalLevelL( NULL, KNewContextSizeEstimate ) ) + { + User::Leave( KErrDiskFull ); + } + + RDbTable contexts; + OpenLC( KDbTableNames, contexts ); + + CDbColSet* colSet = contexts.ColSetL(); + TInt contextNameCol( colSet->ColNo( KDbColumnNamesName ) ); + TInt contextTpsCol( colSet->ColNo( KDbColumnNamesTPS ) ); + TInt contextColIdCol( colSet->ColNo( KDbColumnNamesId ) ); + delete colSet; + colSet = NULL; + + RDbTable proxies; + OpenLC( KDbTableProxies, proxies ); + colSet = proxies.ColSetL(); + TInt proxiesContextIdCol( colSet->ColNo( KDbColumnProxiesContextId ) ); + TInt proxiesProxyCol( colSet->ColNo( KDbColumnProxiesProxy ) ); + delete colSet; + colSet = NULL; + + // All checks done. Now just write the data. + DatabaseBeginLC(); + InsertBeginLC( contexts ); + contexts.SetColL( contextNameCol, aName ); + contexts.SetColL( contextTpsCol, aTPS ); + TUint32 uid( contexts.ColUint32( contextColIdCol ) ); + InsertCommitLP( contexts ); + + for( TInt i( 0 ); i < aProxies.MdcaCount(); i++ ) + { + InsertBeginLC( proxies ); + proxies.SetColL( proxiesContextIdCol, uid ); + proxies.SetColL( proxiesProxyCol, aProxies.MdcaPoint(i) ); + InsertCommitLP( proxies ); + } + + DatabaseCommitLP(); + + CleanupStack::PopAndDestroy(2); // proxies, contexts + return uid; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextUidsL +// ----------------------------------------------------------------------------- +// +CArrayFix* CWPMultiContextManager::ContextUidsL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextUidsL" ) ); + + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + CDbColSet* colset = contexts.ColSetL(); + TInt uidCol( colset->ColNo( KDbColumnNamesId ) ); + delete colset; + + CArrayFix* array = + new(ELeave) CArrayFixFlat( Max( 1, contexts.CountL() ) ); + CleanupStack::PushL( array ); + FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::ContextUidsL: count (%d)"), contexts.CountL())); + contexts.FirstL(); + while( contexts.AtRow() ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextUidsL contexts.GetL()" ) ); + contexts.GetL(); + + TUint32 uid( contexts.ColUint32( uidCol ) ); + array->AppendL( uid ); + contexts.NextL(); + } + + CleanupStack::Pop(); // array + CleanupStack::PopAndDestroy(); // contexts + + return array; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextNameL +// ----------------------------------------------------------------------------- +// +HBufC* CWPMultiContextManager::ContextNameL( TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextNameL" ) ); + + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) ); + if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) ) + { + User::Leave( KErrNotFound ); + } + + CDbColSet* colset = contexts.ColSetL(); + TInt nameCol( colset->ColNo( KDbColumnNamesName ) ); + delete colset; + + contexts.GetL(); + HBufC* name = contexts.ColDes16( nameCol ).AllocL(); + + CleanupStack::PopAndDestroy(); // contexts + return name; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextTPSL +// ----------------------------------------------------------------------------- +// +HBufC* CWPMultiContextManager::ContextTPSL( TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextTPSL" ) ); + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) ); + if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) ) + { + User::Leave( KErrNotFound ); + } + + CDbColSet* colset = contexts.ColSetL(); + TInt tpsCol( colset->ColNo( KDbColumnNamesTPS ) ); + delete colset; + + contexts.GetL(); + HBufC* tps = contexts.ColDes16( tpsCol ).AllocL(); + + CleanupStack::PopAndDestroy(); // contexts + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextTPSL done" ) ); + return tps; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextProxiesL +// ----------------------------------------------------------------------------- +// +CDesCArray* CWPMultiContextManager::ContextProxiesL( TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextProxiesL" ) ); + + CheckDatabaseL(); + + RDbTable proxies; + OpenLC( KDbTableProxies, proxies, RDbRowSet::EReadOnly ); + + CDbColSet* colset = proxies.ColSetL(); + TInt contextCol( colset->ColNo( KDbColumnProxiesContextId ) ); + TInt proxyCol( colset->ColNo( KDbColumnProxiesProxy ) ); + delete colset; + + User::LeaveIfError( proxies.SetIndex( KDbIndexProxiesContextId ) ); + proxies.SeekL( TDbSeekKey( TUint( aUid ) ) ); + + CDesCArray* array = new(ELeave) CDesCArrayFlat( KProxiesGranularity ); + CleanupStack::PushL( array ); + + while( proxies.AtRow() + && (proxies.GetL(), proxies.ColUint32( contextCol ) == aUid ) ) + { + array->AppendL( proxies.ColDes16( proxyCol ) ); + proxies.NextL(); + } + + CleanupStack::Pop(); // array + CleanupStack::PopAndDestroy(); // proxies + + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextProxiesL done" ) ); + return array; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::DeleteContextL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::DeleteContextL( + MWPContextExtensionArray& /*aArray*/, + TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::DeleteContextL" ) ); + + CheckDatabaseL(); + + // If we're deleting the current context, set the current context to null + if( CurrentContextL() == aUid ) + { + SetCurrentContextL( KWPMgrUidNoContext ); + } + + RDbTable contexts; + OpenLC( KDbTableNames, contexts ); + + // Find the line in names table and delete it + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) ); + if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) ) + { + User::Leave( KErrNotFound ); + } + contexts.DeleteL(); + CleanupStack::PopAndDestroy(); // contexts + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::DeleteContextDataL +// ----------------------------------------------------------------------------- +// +TBool CWPMultiContextManager::DeleteContextDataL( + MWPContextExtensionArray& /*aArray*/, + TUint32 /*aUid*/ ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::DeleteContextDataL" ) ); + + // Deleting not supported by MultiContextManager + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextDataCountL +// ----------------------------------------------------------------------------- +// +TInt CWPMultiContextManager::ContextDataCountL( TUint32 /*aUid*/ ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextDataCountL" ) ); + + // Context data gathering not supported by MultiContextManager + return 0; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CurrentContextL +// ----------------------------------------------------------------------------- +// +TUint32 CWPMultiContextManager::CurrentContextL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CurrentContextL" ) ); + + return iCurrentContext; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::SetCurrentContextL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::SetCurrentContextL( TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::SetCurrentContextL" ) ); + + iCurrentContext = aUid; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextExistsL +// ----------------------------------------------------------------------------- +// +TBool CWPMultiContextManager::ContextExistsL( TUint32 aUid ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextExistsL(uid)" ) ); + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) ); + TBool result( contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) ); + + CleanupStack::PopAndDestroy(); // contexts + return result; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextExistsL +// ----------------------------------------------------------------------------- +// +TBool CWPMultiContextManager::ContextExistsL( const TDesC& aTPS ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextExistsL(aTPS)" ) ); + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesTPS ) ); + TBool result( contexts.SeekL( TDbSeekKey( aTPS ) ) ); + + CleanupStack::PopAndDestroy(); // contexts + return result; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::ContextL +// ----------------------------------------------------------------------------- +// +TUint32 CWPMultiContextManager::ContextL( const TDesC& aTPS ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextL" ) ); + CheckDatabaseL(); + + RDbTable contexts; + OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly ); + + User::LeaveIfError( contexts.SetIndex( KDbIndexNamesTPS ) ); + if( !contexts.SeekL( TDbSeekKey( aTPS ) ) ) + { + User::Leave( KErrNotFound ); + } + contexts.GetL(); + + CDbColSet* colset = contexts.ColSetL(); + TUint32 uid( contexts.ColUint32( colset->ColNo( KDbColumnNamesId ) ) ); + delete colset; + + CleanupStack::PopAndDestroy(); // contexts + return uid; + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::SaveL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::SaveL( MWPContextExtension& /*aExtension*/, + TInt /*aItem*/ ) + { + // Context save data not gathered by MultiContextManager + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::DatabaseBeginLC +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::DatabaseBeginLC() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::DatabaseBeginLC" ) ); + + User::LeaveIfError( iDataBase.Begin() ); + CleanupStack::PushL( TCleanupItem( CleanupRollback, &iDataBase ) ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::DatabaseCommitLP +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::DatabaseCommitLP() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::DatabaseCommitLP" ) ); + + User::LeaveIfError( iDataBase.Commit() ); + CleanupStack::Pop(); // CleanupRollback + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CleanupRollback +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CleanupRollback( TAny* aItem ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupRollback" ) ); + + RDbDatabase* db = static_cast(aItem); + db->Rollback(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::InsertBeginLC +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::InsertBeginLC( RDbTable& aTable ) const + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::InsertBeginLC" ) ); + + aTable.InsertL(); + CleanupStack::PushL( TCleanupItem( CleanupCancel, &aTable ) ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::InsertCommitLP +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::InsertCommitLP( RDbTable& aTable ) const + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::InsertCommitLP" ) ); + + aTable.PutL(); + CleanupStack::Pop(); // Cleanup + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CleanupCancel +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CleanupCancel( TAny* aItem ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupCancel" ) ); + + RDbTable* table = static_cast(aItem); + table->Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::CleanupDeleteDb +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::CleanupDeleteDb( TAny* aItem ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupDeleteDb" ) ); + + RFs* fs = static_cast(aItem); + TFileName path; + path.Append( KDbFullName ); + fs->Delete( path ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::OpenLC +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::OpenLC( const TDesC& aName, RDbTable& aTable, + RDbTable::TAccess aAccess ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenLC" ) ); + User::LeaveIfError( aTable.Open( iDataBase, aName, aAccess ) ); + FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenLC OK" ) ); + CleanupClosePushL( aTable ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::RunL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::RunL() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::RunL" ) ); + + for( TInt i( 0 ); i < iObservers.Count(); i++ ) + { + iObservers[i]->ContextChangeL( RDbNotifier::TEvent( iStatus.Int() ) ); + } + IssueRequest(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::DoCancel +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::DoCancel() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::DoCancel" ) ); + + iNotifier.Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::IssueRequest +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::IssueRequest() + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::IssueRequest" ) ); + + iNotifier.NotifyChange( iStatus ); + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::RegisterObserverL +// ----------------------------------------------------------------------------- +// +void CWPMultiContextManager::RegisterContextObserverL( + MWPContextObserver* aObserver ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::RegisterContextObserverL" ) ); + + User::LeaveIfError( iObservers.Append( aObserver ) ); + } + +// ----------------------------------------------------------------------------- +// CWPMultiContextManager::UnregisterContextObserver +// ----------------------------------------------------------------------------- +// +TInt CWPMultiContextManager::UnregisterContextObserver( + MWPContextObserver* aObserver ) + { + FLOG( _L( "[Provisioning] CWPMultiContextManager::UnregisterContextObserver" ) ); + + TInt result( iObservers.Find( aObserver ) ); + + if( result >= 0 ) + { + iObservers.Remove( result ); + result = KErrNone; + } + + return result; + } + + +// End of File