1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Multiple context manager.

    15 *

    16 */

    17 

    18 

    19 //  INCLUDE FILES

    20 #include "CWPMultiContextManager.h"

    21 #include <f32file.h>

    22 #include <d32dbms.h>

    23 #include <badesca.h>

    24 #include <sysutil.h>

    25 #include "MWPContextObserver.h"

    26 #include "ProvisioningDebug.h"

    27 

    28 // CONSTANTS

    29 _LIT( KDbFullName, "C:\\system\\data\\wpcontext.db" );

    30 _LIT( KDbNameDBMS, "c:wpcontext.db" );

    31 _LIT( KDbTableNames, "A" );

    32 _LIT( KDbIndexNamesUid, "AA" );

    33 _LIT( KDbIndexNamesTPS, "AB" );

    34 _LIT( KDbColumnNamesId, "AC" );

    35 _LIT( KDbColumnNamesName, "AD" );

    36 _LIT( KDbColumnNamesTPS, "AE" );

    37 _LIT( KDbTableProxies, "B" );

    38 _LIT( KDbIndexProxiesContextId, "BA" );

    39 _LIT( KDbColumnProxiesContextId, "BB" );

    40 _LIT( KDbColumnProxiesProxy, "BC" );

    41 const TInt KProxiesGranularity = 3;

    42 const TInt KNewContextSizeEstimate = 128;

    43 

    44 #ifdef SYMBIAN_SECURE_DBMS

    45 _LIT(KWPSecureDBMSFormatSpecifier, "SECURE[101F84D6]");

    46 #endif

    47 

    48 const TInt KWPDBMSFileValue = 0x101F84D6;

    49 const TUid KWPDBMSFileUid = { KWPDBMSFileValue };

    50 

    51 // ============================ MEMBER FUNCTIONS ===============================

    52 

    53 // -----------------------------------------------------------------------------

    54 // CWPMultiContextManager::CWPMultiContextManager

    55 // C++ default constructor can NOT contain any code, that

    56 // might leave.

    57 // -----------------------------------------------------------------------------

    58 //

    59 CWPMultiContextManager::CWPMultiContextManager()

    60 : CActive( EPriorityStandard )

    61     {

    62     CActiveScheduler::Add( this );

    63     }

    64 

    65 // -----------------------------------------------------------------------------

    66 // CWPMultiContextManager::ConstructL

    67 // Symbian 2nd phase constructor can leave.

    68 // -----------------------------------------------------------------------------

    69 //

    70 void CWPMultiContextManager::ConstructL()

    71     {

    72     User::LeaveIfError( iDbSession.Connect() );

    73     OpenDatabaseL();

    74     }

    75 

    76 // -----------------------------------------------------------------------------

    77 // CWPMultiContextManager::NewL

    78 // Two-phased constructor.

    79 // -----------------------------------------------------------------------------

    80 //

    81 CWPMultiContextManager* CWPMultiContextManager::NewL()

    82     {

    83     CWPMultiContextManager* self = NewLC();

    84     CleanupStack::Pop();

    85     

    86     return self;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CWPMultiContextManager::NewLC

    91 // Two-phased constructor.

    92 // -----------------------------------------------------------------------------

    93 //

    94 CWPMultiContextManager* CWPMultiContextManager::NewLC()

    95     {

    96     CWPMultiContextManager* self = new( ELeave ) CWPMultiContextManager;

    97     

    98     CleanupStack::PushL( self );

    99     self->ConstructL();

   100     

   101     return self;

   102     }

   103 

   104 // Destructor

   105 CWPMultiContextManager::~CWPMultiContextManager()

   106     {

   107     Cancel();

   108 

   109     iNotifier.Close();

   110     iDataBase.Close();

   111     iDbSession.Close();

   112     iObservers.Close();

   113     }

   114 

   115 // -----------------------------------------------------------------------------

   116 // CWPMultiContextManager::OpenDatabaseL

   117 // -----------------------------------------------------------------------------

   118 //

   119 void CWPMultiContextManager::OpenDatabaseL()

   120     {

   121     FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenDatabaseL" ) );

   122     TInt result = KErrNone;

   123 

   124 #ifdef SYMBIAN_SECURE_DBMS

   125 	result = iDataBase.Open( iDbSession, KDbNameDBMS, KWPSecureDBMSFormatSpecifier );

   126 	FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 1 result (%d)"), result));

   127 #else

   128     iDataBasePath.Zero();

   129     iDataBasePath.Append( KDbFullName );

   130     result = iDataBase.Open( iDbSession, iDataBasePath );

   131     FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 1 result (%d)"), result));

   132     

   133 #endif

   134     if( result == KErrNotFound || result == KErrArgument )

   135         {

   136         FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenDatabaseL close and recreate" ) );

   137         iDataBase.Close();

   138         CreateDatabaseL();

   139      #ifdef SYMBIAN_SECURE_DBMS

   140 	    result = iDataBase.Open( iDbSession, KDbNameDBMS, KWPSecureDBMSFormatSpecifier );

   141      #else

   142         result = iDataBase.Open( iDbSession, iDataBasePath );

   143      #endif

   144         FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::OpenDatabaseL: 2 result (%d)"), result));

   145         }

   146     User::LeaveIfError( result );

   147     CheckDatabaseL();

   148 

   149     User::LeaveIfError( iNotifier.Open( iDataBase ) );

   150     IssueRequest();

   151     }

   152 

   153 // -----------------------------------------------------------------------------

   154 // CWPMultiContextManager::CreateDatabaseL

   155 // -----------------------------------------------------------------------------

   156 //

   157 void CWPMultiContextManager::CreateDatabaseL()

   158     {

   159     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDatabaseL" ) );

   160     

   161     const TName WPContextDbmsTypeName = 

   162         #ifdef SYMBIAN_SECURE_DBMS

   163             KWPSecureDBMSFormatSpecifier();

   164         #else

   165             KWPDBMSFileUid.Name();

   166         #endif

   167     

   168     RDbNamedDatabase db;

   169 #ifdef SYMBIAN_SECURE_DBMS

   170     TInt retval = iDbSession.DeleteDatabase( KDbNameDBMS, KWPDBMSFileUid );

   171     

   172     retval = iDataBase.Create( iDbSession, KDbNameDBMS, WPContextDbmsTypeName );

   173     FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::CreateDatabaseL: retval (%d)"), retval));

   174     CleanupClosePushL( iDataBase );

   175 

   176     CreateNamesTableL( iDataBase );

   177     CreateProxiesTableL( iDataBase );

   178     CreateDataTableL( iDataBase );

   179 

   180     CleanupStack::PopAndDestroy(); // iDataBase

   181     

   182 #else

   183     RFs fs;

   184     User::LeaveIfError( fs.Connect() );

   185     CleanupClosePushL( fs );

   186 

   187     if( SysUtil::FFSSpaceBelowCriticalLevelL( &fs, KEmptyDbSizeEstimate ) )

   188         {

   189         User::Leave( KErrDiskFull );

   190         }

   191     iDataBasePath.Zero();

   192     iDataBasePath.Append( KDbFullName );

   193     // Make sure the database file does not exist

   194     fs.Delete( iDataBasePath );

   195     CleanupStack::PushL( TCleanupItem( CleanupDeleteDb, &fs ) );

   196 

   197     User::LeaveIfError( db.Create( fs, iDataBasePath ) );

   198     

   199     CleanupClosePushL( db );

   200 

   201     CreateNamesTableL( db );

   202     CreateProxiesTableL( db );

   203     CreateDataTableL( db );

   204 

   205     CleanupStack::PopAndDestroy(); // db

   206     CleanupStack::Pop(); // deleteDb

   207     CleanupStack::PopAndDestroy(); // fs   

   208 #endif

   209     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDatabaseL done:" ) );

   210     }

   211 

   212 // -----------------------------------------------------------------------------

   213 // CWPMultiContextManager::CheckDatabaseL

   214 // -----------------------------------------------------------------------------

   215 //

   216 void CWPMultiContextManager::CheckDatabaseL()

   217     {

   218     FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL" ) );

   219     if( iDataBase.IsDamaged() )

   220         {

   221         FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL damaged" ) );

   222         User::LeaveIfError( iDataBase.Recover() );

   223         }

   224     FLOG( _L( "[Provisioning] CWPMultiContextManager::CheckDatabaseL OK" ) );

   225     }

   226 

   227 // -----------------------------------------------------------------------------

   228 // CWPMultiContextManager::CreateNamesTableL

   229 // -----------------------------------------------------------------------------

   230 //

   231 void CWPMultiContextManager::CreateNamesTableL( RDbDatabase& aDb )

   232     {

   233     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateNamesTableL" ) );

   234     

   235     // Create the actual table

   236     CDbColSet* colset = CDbColSet::NewLC();

   237     TDbCol idCol( KDbColumnNamesId, EDbColUint32 );

   238     idCol.iAttributes = TDbCol::EAutoIncrement;

   239     colset->AddL( idCol );

   240     TDbCol nameCol( KDbColumnNamesName, EDbColText16 );

   241     colset->AddL( nameCol );

   242     TDbCol tpsCol( KDbColumnNamesTPS, EDbColText16 );

   243     tpsCol.iAttributes = TDbCol::ENotNull;

   244     colset->AddL( tpsCol );

   245     User::LeaveIfError( aDb.CreateTable( KDbTableNames, *colset ) );

   246     CleanupStack::PopAndDestroy(); // colset

   247 

   248     // Index for searching by UID

   249     CDbKey* key = CDbKey::NewLC();

   250     TDbKeyCol idkeyCol( KDbColumnNamesId );

   251     key->AddL( idkeyCol );

   252     User::LeaveIfError( 

   253         aDb.CreateIndex( KDbIndexNamesUid, KDbTableNames, *key ) );

   254     CleanupStack::PopAndDestroy(); // key

   255 

   256     // Index for searching by TPS

   257     key = CDbKey::NewLC();

   258     TDbKeyCol tpskeyCol( KDbColumnNamesTPS );

   259     key->AddL( tpskeyCol );

   260     User::LeaveIfError( 

   261         aDb.CreateIndex( KDbIndexNamesTPS, KDbTableNames, *key ) );

   262     CleanupStack::PopAndDestroy(); // key

   263     }

   264 

   265 // -----------------------------------------------------------------------------

   266 // CWPMultiContextManager::CreateProxiesTableL

   267 // -----------------------------------------------------------------------------

   268 //

   269 void CWPMultiContextManager::CreateProxiesTableL( RDbDatabase& aDb )

   270     {

   271     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateProxiesTableL" ) );

   272     

   273     // Create the actual table

   274     CDbColSet* colset = CDbColSet::NewLC();

   275     TDbCol contextIdCol( KDbColumnProxiesContextId, EDbColUint32 );

   276     contextIdCol.iAttributes = TDbCol::ENotNull;

   277     colset->AddL( contextIdCol );

   278     TDbCol proxyCol( KDbColumnProxiesProxy, EDbColText );

   279     proxyCol.iAttributes = TDbCol::ENotNull;

   280     colset->AddL( proxyCol );

   281     User::LeaveIfError( aDb.CreateTable( KDbTableProxies, *colset ) );

   282     CleanupStack::PopAndDestroy(); // colset

   283 

   284     // Index for searching by context UID

   285     CDbKey* key = CDbKey::NewLC();

   286     TDbKeyCol contextkeyCol( KDbColumnProxiesContextId );

   287     key->AddL( contextkeyCol );

   288     User::LeaveIfError( 

   289         aDb.CreateIndex( KDbIndexProxiesContextId, KDbTableProxies, *key ) );

   290     CleanupStack::PopAndDestroy(); // key

   291     }

   292 

   293 // -----------------------------------------------------------------------------

   294 // CWPMultiContextManager::CreateDataTableL

   295 // -----------------------------------------------------------------------------

   296 //

   297 void CWPMultiContextManager::CreateDataTableL( RDbDatabase& aDb )

   298     {

   299     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateDataTableL" ) );

   300     

   301     // Create the actual table

   302     CDbColSet* colset = CDbColSet::NewLC();

   303     TDbCol contextIdCol( KDbColumnDataContextId, EDbColUint32 );

   304     contextIdCol.iAttributes = TDbCol::ENotNull;

   305     colset->AddL( contextIdCol );

   306     TDbCol adapterIdCol( KDbColumnDataAdapterId, EDbColUint32 );

   307     adapterIdCol.iAttributes = TDbCol::ENotNull;

   308     colset->AddL( adapterIdCol );

   309     TDbCol saveDataCol( KDbColumnDataSaveData, EDbColBinary );

   310     colset->AddL( saveDataCol );

   311     User::LeaveIfError( aDb.CreateTable( KDbTableData, *colset ) );

   312     CleanupStack::PopAndDestroy(); // colset

   313 

   314     // Index for searching by context UID and adapter UID

   315     CDbKey* key = CDbKey::NewLC();

   316     TDbKeyCol contextkeyCol( KDbColumnDataContextId );

   317     key->AddL( contextkeyCol );

   318     TDbKeyCol adapterkeyCol( KDbColumnDataAdapterId );

   319     key->AddL( adapterkeyCol );

   320     User::LeaveIfError( 

   321         aDb.CreateIndex( KDbIndexDataContextId, KDbTableData, *key ) );

   322     CleanupStack::PopAndDestroy(); // key

   323     }

   324 

   325 // -----------------------------------------------------------------------------

   326 // CWPMultiContextManager::CreateContextL

   327 // -----------------------------------------------------------------------------

   328 //

   329 TUint32 CWPMultiContextManager::CreateContextL( const TDesC& aName,

   330                                                 const TDesC& aTPS, 

   331                                                 const MDesCArray& aProxies )

   332     {

   333     FLOG( _L( "[Provisioning] CWPMultiContextManager::CreateContextL" ) );

   334 

   335     CheckDatabaseL();

   336 

   337     // Check if a context has been created for the particular TPS

   338     if( ContextExistsL( aTPS ) )

   339         {

   340         User::Leave( KErrAlreadyExists );

   341         }

   342 

   343     if( SysUtil::FFSSpaceBelowCriticalLevelL( NULL, KNewContextSizeEstimate ) )

   344         {

   345         User::Leave( KErrDiskFull );

   346         }

   347 

   348     RDbTable contexts;

   349     OpenLC( KDbTableNames, contexts );

   350 

   351     CDbColSet* colSet = contexts.ColSetL();

   352     TInt contextNameCol( colSet->ColNo( KDbColumnNamesName ) );

   353     TInt contextTpsCol( colSet->ColNo( KDbColumnNamesTPS ) );

   354     TInt contextColIdCol( colSet->ColNo( KDbColumnNamesId ) );

   355     delete colSet;

   356     colSet = NULL;

   357 

   358     RDbTable proxies;

   359     OpenLC( KDbTableProxies, proxies );

   360     colSet = proxies.ColSetL();

   361     TInt proxiesContextIdCol( colSet->ColNo( KDbColumnProxiesContextId ) );

   362     TInt proxiesProxyCol( colSet->ColNo( KDbColumnProxiesProxy ) );

   363     delete colSet;

   364     colSet = NULL;

   365 

   366     // All checks done. Now just write the data.

   367     DatabaseBeginLC();

   368     InsertBeginLC( contexts );

   369     contexts.SetColL( contextNameCol, aName );

   370     contexts.SetColL( contextTpsCol, aTPS );

   371     TUint32 uid( contexts.ColUint32( contextColIdCol ) );

   372     InsertCommitLP( contexts );

   373     

   374     for( TInt i( 0 ); i < aProxies.MdcaCount(); i++ )

   375         {

   376         InsertBeginLC( proxies );

   377         proxies.SetColL( proxiesContextIdCol, uid );

   378         proxies.SetColL( proxiesProxyCol, aProxies.MdcaPoint(i) );

   379         InsertCommitLP( proxies );

   380         }

   381     

   382     DatabaseCommitLP();

   383 

   384     CleanupStack::PopAndDestroy(2); // proxies, contexts

   385     return uid;

   386     }

   387 

   388 // -----------------------------------------------------------------------------

   389 // CWPMultiContextManager::ContextUidsL

   390 // -----------------------------------------------------------------------------

   391 //

   392 CArrayFix<TUint32>* CWPMultiContextManager::ContextUidsL()

   393     {

   394     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextUidsL" ) );

   395 

   396     CheckDatabaseL();

   397 

   398     RDbTable contexts;

   399     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   400     CDbColSet* colset = contexts.ColSetL();

   401     TInt uidCol( colset->ColNo( KDbColumnNamesId ) );

   402     delete colset;

   403 

   404     CArrayFix<TUint32>* array = 

   405         new(ELeave) CArrayFixFlat<TUint32>( Max( 1, contexts.CountL() ) );

   406     CleanupStack::PushL( array );

   407     FTRACE(RDebug::Print(_L("[Provisioning] CWPMultiContextManager::ContextUidsL: count (%d)"), contexts.CountL()));

   408     contexts.FirstL();

   409     while( contexts.AtRow() )

   410         {

   411         FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextUidsL contexts.GetL()" ) );

   412         contexts.GetL();

   413 

   414         TUint32 uid( contexts.ColUint32( uidCol ) );

   415         array->AppendL( uid );

   416         contexts.NextL();

   417         }

   418 

   419     CleanupStack::Pop(); // array

   420     CleanupStack::PopAndDestroy(); // contexts

   421 

   422     return array;

   423     }

   424 

   425 // -----------------------------------------------------------------------------

   426 // CWPMultiContextManager::ContextNameL

   427 // -----------------------------------------------------------------------------

   428 //

   429 HBufC* CWPMultiContextManager::ContextNameL( TUint32 aUid )

   430     {

   431     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextNameL" ) );

   432     

   433     CheckDatabaseL();

   434 

   435     RDbTable contexts;

   436     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   437 

   438     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) );

   439     if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) )

   440         {

   441         User::Leave( KErrNotFound );

   442         }

   443 

   444     CDbColSet* colset = contexts.ColSetL();

   445     TInt nameCol( colset->ColNo( KDbColumnNamesName ) );

   446     delete colset;

   447     

   448     contexts.GetL();

   449     HBufC* name = contexts.ColDes16( nameCol ).AllocL();

   450 

   451     CleanupStack::PopAndDestroy(); // contexts

   452     return name;

   453     }

   454 

   455 // -----------------------------------------------------------------------------

   456 // CWPMultiContextManager::ContextTPSL

   457 // -----------------------------------------------------------------------------

   458 //

   459 HBufC* CWPMultiContextManager::ContextTPSL( TUint32 aUid )

   460     {

   461     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextTPSL" ) );

   462     CheckDatabaseL();

   463 

   464     RDbTable contexts;

   465     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   466 

   467     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) );

   468     if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) )

   469         {

   470         User::Leave( KErrNotFound );

   471         }

   472 

   473     CDbColSet* colset = contexts.ColSetL();

   474     TInt tpsCol( colset->ColNo( KDbColumnNamesTPS ) );

   475     delete colset;

   476     

   477     contexts.GetL();

   478     HBufC* tps = contexts.ColDes16( tpsCol ).AllocL();

   479 

   480     CleanupStack::PopAndDestroy(); // contexts

   481     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextTPSL done" ) );

   482     return tps;

   483     }

   484 

   485 // -----------------------------------------------------------------------------

   486 // CWPMultiContextManager::ContextProxiesL

   487 // -----------------------------------------------------------------------------

   488 //

   489 CDesCArray* CWPMultiContextManager::ContextProxiesL( TUint32 aUid )

   490     {

   491     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextProxiesL" ) );

   492     

   493     CheckDatabaseL();

   494 

   495     RDbTable proxies;

   496     OpenLC( KDbTableProxies, proxies, RDbRowSet::EReadOnly );

   497 

   498     CDbColSet* colset = proxies.ColSetL();

   499     TInt contextCol( colset->ColNo( KDbColumnProxiesContextId ) );

   500     TInt proxyCol( colset->ColNo( KDbColumnProxiesProxy ) );

   501     delete colset;

   502 

   503     User::LeaveIfError( proxies.SetIndex( KDbIndexProxiesContextId ) );

   504     proxies.SeekL( TDbSeekKey( TUint( aUid ) ) );

   505 

   506     CDesCArray* array = new(ELeave) CDesCArrayFlat( KProxiesGranularity );

   507     CleanupStack::PushL( array );

   508 

   509     while( proxies.AtRow()

   510         && (proxies.GetL(), proxies.ColUint32( contextCol ) == aUid ) )

   511         {

   512         array->AppendL( proxies.ColDes16( proxyCol ) );

   513         proxies.NextL();

   514         }

   515     

   516     CleanupStack::Pop(); // array

   517     CleanupStack::PopAndDestroy(); // proxies

   518     

   519     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextProxiesL done" ) );

   520     return array;

   521     }

   522 

   523 // -----------------------------------------------------------------------------

   524 // CWPMultiContextManager::DeleteContextL

   525 // -----------------------------------------------------------------------------

   526 //

   527 void CWPMultiContextManager::DeleteContextL( 

   528                                           MWPContextExtensionArray& /*aArray*/, 

   529                                           TUint32 aUid )

   530     {

   531     FLOG( _L( "[Provisioning] CWPMultiContextManager::DeleteContextL" ) );

   532     

   533     CheckDatabaseL();

   534 

   535     // If we're deleting the current context, set the current context to null

   536     if( CurrentContextL() == aUid )

   537         {

   538         SetCurrentContextL( KWPMgrUidNoContext );

   539         }

   540 

   541     RDbTable contexts;

   542     OpenLC( KDbTableNames, contexts );

   543     

   544     // Find the line in names table and delete it

   545     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) );

   546     if( !contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) )

   547         {

   548         User::Leave( KErrNotFound );

   549         }

   550     contexts.DeleteL();

   551     CleanupStack::PopAndDestroy(); // contexts

   552     }

   553 

   554 // -----------------------------------------------------------------------------

   555 // CWPMultiContextManager::DeleteContextDataL

   556 // -----------------------------------------------------------------------------

   557 //

   558 TBool CWPMultiContextManager::DeleteContextDataL( 

   559                                           MWPContextExtensionArray& /*aArray*/,

   560                                           TUint32 /*aUid*/ )

   561     {

   562     FLOG( _L( "[Provisioning] CWPMultiContextManager::DeleteContextDataL" ) );

   563     

   564     // Deleting not supported by MultiContextManager

   565     return EFalse;

   566     }

   567 

   568 // -----------------------------------------------------------------------------

   569 // CWPMultiContextManager::ContextDataCountL

   570 // -----------------------------------------------------------------------------

   571 //

   572 TInt CWPMultiContextManager::ContextDataCountL( TUint32 /*aUid*/ )

   573     {

   574     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextDataCountL" ) );

   575     

   576     // Context data gathering not supported by MultiContextManager

   577     return 0;

   578     }

   579 

   580 // -----------------------------------------------------------------------------

   581 // CWPMultiContextManager::CurrentContextL

   582 // -----------------------------------------------------------------------------

   583 //

   584 TUint32 CWPMultiContextManager::CurrentContextL()

   585     {

   586     FLOG( _L( "[Provisioning] CWPMultiContextManager::CurrentContextL" ) );

   587     

   588     return iCurrentContext;

   589     }

   590 

   591 // -----------------------------------------------------------------------------

   592 // CWPMultiContextManager::SetCurrentContextL

   593 // -----------------------------------------------------------------------------

   594 //

   595 void CWPMultiContextManager::SetCurrentContextL( TUint32 aUid )

   596     {

   597     FLOG( _L( "[Provisioning] CWPMultiContextManager::SetCurrentContextL" ) );

   598     

   599     iCurrentContext = aUid;

   600     }

   601 

   602 // -----------------------------------------------------------------------------

   603 // CWPMultiContextManager::ContextExistsL

   604 // -----------------------------------------------------------------------------

   605 //

   606 TBool CWPMultiContextManager::ContextExistsL( TUint32 aUid )

   607     {

   608     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextExistsL(uid)" ) );

   609     CheckDatabaseL();

   610 

   611     RDbTable contexts;

   612     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   613 

   614     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesUid ) );

   615     TBool result( contexts.SeekL( TDbSeekKey( TUint( aUid ) ) ) );

   616 

   617     CleanupStack::PopAndDestroy(); // contexts

   618     return result;

   619     }

   620 

   621 // -----------------------------------------------------------------------------

   622 // CWPMultiContextManager::ContextExistsL

   623 // -----------------------------------------------------------------------------

   624 //

   625 TBool CWPMultiContextManager::ContextExistsL( const TDesC& aTPS )

   626     {

   627     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextExistsL(aTPS)" ) );

   628     CheckDatabaseL();

   629 

   630     RDbTable contexts;

   631     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   632 

   633     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesTPS ) );

   634     TBool result( contexts.SeekL( TDbSeekKey( aTPS ) ) );

   635 

   636     CleanupStack::PopAndDestroy(); // contexts

   637     return result;

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // CWPMultiContextManager::ContextL

   642 // -----------------------------------------------------------------------------

   643 //

   644 TUint32 CWPMultiContextManager::ContextL( const TDesC& aTPS )

   645     {

   646     FLOG( _L( "[Provisioning] CWPMultiContextManager::ContextL" ) );

   647     CheckDatabaseL();

   648 

   649     RDbTable contexts;

   650     OpenLC( KDbTableNames, contexts, RDbRowSet::EReadOnly );

   651 

   652     User::LeaveIfError( contexts.SetIndex( KDbIndexNamesTPS ) );

   653     if( !contexts.SeekL( TDbSeekKey( aTPS ) ) )

   654         {

   655         User::Leave( KErrNotFound );

   656         }

   657     contexts.GetL();

   658 

   659     CDbColSet* colset = contexts.ColSetL();

   660     TUint32 uid( contexts.ColUint32( colset->ColNo( KDbColumnNamesId ) ) );

   661     delete colset;

   662 

   663     CleanupStack::PopAndDestroy(); // contexts

   664     return uid;

   665     }

   666 

   667 // -----------------------------------------------------------------------------

   668 // CWPMultiContextManager::SaveL

   669 // -----------------------------------------------------------------------------

   670 //

   671 void CWPMultiContextManager::SaveL( MWPContextExtension& /*aExtension*/,

   672                                     TInt /*aItem*/ )

   673     {

   674     // Context save data not gathered by MultiContextManager

   675     }

   676 

   677 // -----------------------------------------------------------------------------

   678 // CWPMultiContextManager::DatabaseBeginLC

   679 // -----------------------------------------------------------------------------

   680 //

   681 void CWPMultiContextManager::DatabaseBeginLC()

   682     {

   683     FLOG( _L( "[Provisioning] CWPMultiContextManager::DatabaseBeginLC" ) );

   684     

   685     User::LeaveIfError( iDataBase.Begin() );

   686     CleanupStack::PushL( TCleanupItem( CleanupRollback, &iDataBase ) );

   687     }

   688 

   689 // -----------------------------------------------------------------------------

   690 // CWPMultiContextManager::DatabaseCommitLP

   691 // -----------------------------------------------------------------------------

   692 //

   693 void CWPMultiContextManager::DatabaseCommitLP()

   694     {

   695     FLOG( _L( "[Provisioning] CWPMultiContextManager::DatabaseCommitLP" ) );

   696     

   697     User::LeaveIfError( iDataBase.Commit() );

   698     CleanupStack::Pop(); // CleanupRollback

   699     }

   700 

   701 // -----------------------------------------------------------------------------

   702 // CWPMultiContextManager::CleanupRollback

   703 // -----------------------------------------------------------------------------

   704 //

   705 void CWPMultiContextManager::CleanupRollback( TAny* aItem )

   706     {

   707     FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupRollback" ) );

   708     

   709     RDbDatabase* db = static_cast<RDbDatabase*>(aItem);

   710     db->Rollback();

   711     }

   712 

   713 // -----------------------------------------------------------------------------

   714 // CWPMultiContextManager::InsertBeginLC

   715 // -----------------------------------------------------------------------------

   716 //

   717 void CWPMultiContextManager::InsertBeginLC( RDbTable& aTable ) const

   718     {

   719     FLOG( _L( "[Provisioning] CWPMultiContextManager::InsertBeginLC" ) );

   720     

   721     aTable.InsertL();

   722     CleanupStack::PushL( TCleanupItem( CleanupCancel, &aTable ) );

   723     }

   724 

   725 // -----------------------------------------------------------------------------

   726 // CWPMultiContextManager::InsertCommitLP

   727 // -----------------------------------------------------------------------------

   728 //

   729 void CWPMultiContextManager::InsertCommitLP( RDbTable& aTable ) const

   730     {

   731     FLOG( _L( "[Provisioning] CWPMultiContextManager::InsertCommitLP" ) );

   732     

   733     aTable.PutL();

   734     CleanupStack::Pop(); // Cleanup

   735     }

   736 

   737 // -----------------------------------------------------------------------------

   738 // CWPMultiContextManager::CleanupCancel

   739 // -----------------------------------------------------------------------------

   740 //

   741 void CWPMultiContextManager::CleanupCancel( TAny* aItem )

   742     {

   743     FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupCancel" ) );

   744     

   745     RDbTable* table = static_cast<RDbTable*>(aItem);

   746     table->Cancel();

   747     }

   748 

   749 // -----------------------------------------------------------------------------

   750 // CWPMultiContextManager::CleanupDeleteDb

   751 // -----------------------------------------------------------------------------

   752 //

   753 void CWPMultiContextManager::CleanupDeleteDb( TAny* aItem )

   754     {

   755     FLOG( _L( "[Provisioning] CWPMultiContextManager::CleanupDeleteDb" ) );

   756     

   757     RFs* fs = static_cast<RFs*>(aItem);

   758     TFileName path;

   759     path.Append( KDbFullName ); 

   760     fs->Delete( path );

   761     }

   762 

   763 // -----------------------------------------------------------------------------

   764 // CWPMultiContextManager::OpenLC

   765 // -----------------------------------------------------------------------------

   766 //

   767 void CWPMultiContextManager::OpenLC( const TDesC& aName, RDbTable& aTable, 

   768                                     RDbTable::TAccess aAccess )

   769     {

   770     FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenLC" ) );

   771     User::LeaveIfError( aTable.Open( iDataBase, aName, aAccess ) );

   772     FLOG( _L( "[Provisioning] CWPMultiContextManager::OpenLC OK" ) );

   773     CleanupClosePushL( aTable );

   774     }

   775 

   776 // -----------------------------------------------------------------------------

   777 // CWPMultiContextManager::RunL

   778 // -----------------------------------------------------------------------------

   779 //

   780 void CWPMultiContextManager::RunL()

   781     {

   782     FLOG( _L( "[Provisioning] CWPMultiContextManager::RunL" ) );

   783     

   784     for( TInt i( 0 ); i < iObservers.Count(); i++ )

   785         {

   786         iObservers[i]->ContextChangeL( RDbNotifier::TEvent( iStatus.Int() ) );

   787         }

   788     IssueRequest();

   789     }

   790 

   791 // -----------------------------------------------------------------------------

   792 // CWPMultiContextManager::DoCancel

   793 // -----------------------------------------------------------------------------

   794 //

   795 void CWPMultiContextManager::DoCancel()

   796     {

   797     FLOG( _L( "[Provisioning] CWPMultiContextManager::DoCancel" ) );

   798     

   799     iNotifier.Cancel();

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // CWPMultiContextManager::IssueRequest

   804 // -----------------------------------------------------------------------------

   805 //

   806 void CWPMultiContextManager::IssueRequest()

   807     {

   808     FLOG( _L( "[Provisioning] CWPMultiContextManager::IssueRequest" ) );

   809 

   810     iNotifier.NotifyChange( iStatus );

   811     SetActive();

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // CWPMultiContextManager::RegisterObserverL

   816 // -----------------------------------------------------------------------------

   817 //

   818 void CWPMultiContextManager::RegisterContextObserverL( 

   819     MWPContextObserver* aObserver )

   820     {

   821     FLOG( _L( "[Provisioning] CWPMultiContextManager::RegisterContextObserverL" ) );

   822     

   823     User::LeaveIfError( iObservers.Append( aObserver ) );

   824     }

   825 

   826 // -----------------------------------------------------------------------------

   827 // CWPMultiContextManager::UnregisterContextObserver

   828 // -----------------------------------------------------------------------------

   829 //

   830 TInt CWPMultiContextManager::UnregisterContextObserver( 

   831     MWPContextObserver* aObserver )

   832     {

   833     FLOG( _L( "[Provisioning] CWPMultiContextManager::UnregisterContextObserver" ) );

   834     

   835     TInt result( iObservers.Find( aObserver ) );

   836 

   837     if( result >= 0 )

   838         {

   839         iObservers.Remove( result );

   840         result = KErrNone;

   841         }

   842 

   843     return result;

   844     }

   845 

   846 

   847 //  End of File