1 /*

     2 * Copyright (c) 2006-2006 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:  Implementation of the preset database

    15 *

    16 */

    17 

    18 

    19 #include <bautils.h>

    20 #include <pscommon.h>

    21 

    22 #include "psdebug.h"

    23 #include "pspendingpreset.h"

    24 #include "psdatabase.h"

    25 #include "pspresetobserver.h"

    26 

    27 // Uncomment the line below to get database print outs.

    28 // Warning! This may cause a lot of debug messages, so use with caution.

    29 // #define PS_DATABASE_PRINT_DEBUG

    30 

    31 #ifdef PS_DATABASE_PRINT_DEBUG

    32     #define PS_PRINT_DATABASE  RPSDatabase::PrintDatabaseL()

    33 #else

    34     #define PS_PRINT_DATABASE

    35 #endif

    36 

    37 const TInt KPSDatabaseVersion   = 1; // The latest version of the database. Must be kept up to date when adding new versions.

    38 

    39 const TInt KPSDatabaseVersion1  = 1; // Database version 1 identifier.

    40 

    41 // This array contains function pointers to all database update packages. One update corresponds to one function call, therefore

    42 // when adding new database updates it is imperative that this array be updated as well.

    43 

    44 const RPSDatabase::KPSDatabaseUpdateFunction RPSDatabase::iDatabaseUpdateFunctions[] =

    45     {

    46         &RPSDatabase::CreateTablesL

    47     };

    48 

    49 // Table and columns literals.

    50 

    51 _LIT( KPSPresetsTable,              "Presets" );

    52 _LIT( KPSPresetsIdColumn,           "Id" );

    53 _LIT( KPSPresetsNameColumn,         "Name" );

    54 _LIT( KPSPresetsIndexColumn,        "Index" );

    55 _LIT( KPSPresetsDataHandlerColumn,  "DataHandler" );

    56 _LIT( KPSPresetsDataColumn,         "Data" );

    57 

    58 _LIT( KPSVersionsTable,             "Versions" );

    59 _LIT( KPSVersionsVersionColumn,     "Version" );

    60 

    61 // ======== LOCAL FUNCTIONS ========

    62 

    63 // ======== MEMBER FUNCTIONS ========

    64 

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

    66 // Constructor.

    67 // ---------------------------------------------------------------------------

    68 //

    69 RPSDatabase::RPSDatabase( MPSPresetObserver& aObserver )

    70     : RDbNamedDatabase(), iObserver( aObserver )

    71     {

    72     }

    73 

    74 // ---------------------------------------------------------------------------

    75 // Opens the database.

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

    77 //

    78 void RPSDatabase::OpenL( RFs& aFs, const TDesC& aFileName )

    79     {

    80     Close(); // Ensure that the database is closed before trying to open it.

    81 

    82     BaflUtils::EnsurePathExistsL( aFs, aFileName );

    83 

    84     TInt err = RDbNamedDatabase::Create( aFs, aFileName );

    85     

    86     if ( err == KErrAlreadyExists )

    87         {

    88         // The database already existed, need to open it.

    89         User::LeaveIfError( RDbNamedDatabase::Open( aFs, aFileName ) );

    90         }

    91     else

    92         {

    93         User::LeaveIfError( err );

    94         }

    95         

    96     if ( IsDamaged() || !InTransaction() )

    97         {

    98         err = Recover();

    99         

   100         if ( !err )

   101             {

   102             err = Compact();

   103             }

   104         }

   105 

   106     if ( err )

   107         {

   108         Close();

   109         User::Leave( err );

   110         }

   111 

   112     // The database is now open and functional, check if the structure needs to be updated.

   113     TRAP( err, UpdateDatabaseL() )

   114     

   115     if ( err )

   116         {

   117         Destroy();

   118         User::Leave( err );

   119         }

   120 

   121     PS_PRINT_DATABASE;

   122     }

   123 

   124 // ---------------------------------------------------------------------------

   125 // Deletes all presets whose data handler is no longer available.

   126 // ---------------------------------------------------------------------------

   127 //

   128 void RPSDatabase::DeleteOrphanedPresetsL( const RArray<TInt>& aDataHandlers )

   129     {

   130     PS_PRINT_DATABASE;

   131 

   132     _LIT( sql, "DELETE FROM %S" );

   133     _LIT( sqlWhere, " WHERE %S <> %d" );

   134     _LIT( sqlAnd, " AND %S <> %d" );

   135 

   136     TInt count = aDataHandlers.Count();

   137 

   138     // Constructs the query that selects all presets that have no registered data handlers.

   139     

   140     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsTable().Length() + count * KDefaultRealWidth +

   141                                   Min( 1, count ) * (sqlWhere().Length() + KPSPresetsDataHandlerColumn().Length()) +

   142                                   Max( 0, count - 1 ) * (sqlAnd().Length() + KPSPresetsDataHandlerColumn().Length()) );

   143 

   144     TPtr sqlPtr( sqlBuf->Des() );

   145     sqlPtr.Format( sql, &KPSPresetsTable );

   146     

   147     if ( count > 0 )

   148         {

   149         HBufC* tempBuf = HBufC::NewLC( sqlWhere().Length() + KPSPresetsDataHandlerColumn().Length() + KDefaultRealWidth );

   150         tempBuf->Des().Format( sqlWhere, &KPSPresetsDataHandlerColumn, aDataHandlers[0] );

   151         sqlPtr.Append( *tempBuf );

   152         CleanupStack::PopAndDestroy( tempBuf );

   153 

   154         for ( TInt i = 1; i < count; i++ )

   155             {

   156             tempBuf = HBufC::NewLC( sqlAnd().Length() + KPSPresetsDataHandlerColumn().Length() + KDefaultRealWidth );

   157             tempBuf->Des().Format( sqlAnd, &KPSPresetsDataHandlerColumn, aDataHandlers[i] );

   158             sqlPtr.Append( *tempBuf );

   159             CleanupStack::PopAndDestroy( tempBuf );

   160             }

   161         }

   162 

   163     TInt rowsDeleted = Execute ( sqlPtr );

   164     User::LeaveIfError(rowsDeleted);

   165     

   166     CleanupStack::PopAndDestroy( sqlBuf );

   167 

   168     if (rowsDeleted > 0)

   169     	{

   170         User::LeaveIfError( Compact() );

   171     	}

   172 

   173     PS_PRINT_DATABASE;

   174     }

   175 

   176 // ---------------------------------------------------------------------------

   177 // Gets all presets matching the supplied data handler.

   178 // ---------------------------------------------------------------------------

   179 //

   180 void RPSDatabase::GetPresetListL( RArray<TInt>& aPresets, TUid aDataHandler )

   181     {

   182     HBufC* sqlBuf = NULL;

   183 

   184     if ( aDataHandler == KNullUid )

   185         {

   186         _LIT( sql, "SELECT %S FROM %S" );

   187         

   188         sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsIdColumn().Length() + KPSPresetsTable().Length() );

   189         

   190         sqlBuf->Des().Format( sql, &KPSPresetsIdColumn, &KPSPresetsTable );

   191         }

   192     else

   193         {

   194         _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   195         

   196         sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsIdColumn().Length() + KPSPresetsTable().Length() +

   197                                       KPSPresetsDataHandlerColumn().Length() + KDefaultRealWidth );

   198         

   199         sqlBuf->Des().Format( sql, &KPSPresetsIdColumn, &KPSPresetsTable, &KPSPresetsDataHandlerColumn, aDataHandler.iUid );

   200         }

   201 

   202     RDbView view;

   203     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   204     CleanupStack::PopAndDestroy( sqlBuf );

   205     CleanupClosePushL( view );

   206 

   207     CDbColSet* columns = view.ColSetL();

   208     TInt idColumn = columns->ColNo( KPSPresetsIdColumn );

   209     delete columns;

   210 

   211     for ( view.FirstL(); view.AtRow(); view.NextL() )

   212         {

   213         view.GetL();

   214         aPresets.AppendL( view.ColInt32( idColumn ) );

   215         }

   216 

   217     CleanupStack::PopAndDestroy( &view );                                  

   218     }

   219 

   220 // ---------------------------------------------------------------------------

   221 // Creates a preset.

   222 // ---------------------------------------------------------------------------

   223 //

   224 TInt RPSDatabase::CreatePresetL( TInt aIndex, TUid aDataHandler )

   225     {

   226     PS_PRINT_DATABASE;

   227 

   228     _LIT( sql, "SELECT * FROM %S WHERE %S = %d AND %S = %d" );

   229     

   230     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsTable().Length() + KPSPresetsIndexColumn().Length() +

   231                                   KPSPresetsDataHandlerColumn().Length() + 2 * KDefaultRealWidth );

   232     

   233     sqlBuf->Des().Format( sql, &KPSPresetsTable, &KPSPresetsIndexColumn, aIndex, &KPSPresetsDataHandlerColumn, aDataHandler.iUid );

   234 

   235     RDbView view;

   236     User::LeaveIfError( view.Prepare( *this, *sqlBuf ) );

   237     CleanupStack::PopAndDestroy( sqlBuf );

   238     CleanupClosePushL( view );

   239     User::LeaveIfError( view.EvaluateAll() );

   240 

   241     TInt id = KErrNotFound;

   242     

   243     if ( view.FirstL() )

   244         {

   245         User::Leave( KErrAlreadyExists );

   246         }

   247     else

   248         {

   249         view.InsertL();

   250         

   251         CDbColSet* columns = view.ColSetL();

   252         TInt indexColumn = columns->ColNo( KPSPresetsIndexColumn );

   253         TInt dataHandlerColumn = columns->ColNo( KPSPresetsDataHandlerColumn );

   254         TInt idColumn = columns->ColNo( KPSPresetsIdColumn );

   255         delete columns;

   256         

   257         view.SetColL( indexColumn, aIndex );

   258         view.SetColL( dataHandlerColumn, aDataHandler.iUid );

   259         

   260         view.PutL();

   261         

   262         id = view.ColInt32( idColumn );

   263         

   264         iObserver.HandlePresetChangedL( id, aDataHandler, MPSPresetObserver::EPSCreated );

   265         }

   266         

   267     CleanupStack::PopAndDestroy( &view );

   268 

   269     PS_PRINT_DATABASE;

   270 

   271     return id;

   272     }

   273 

   274 // ---------------------------------------------------------------------------

   275 // Deletes a preset.

   276 // ---------------------------------------------------------------------------

   277 //

   278 void RPSDatabase::DeletePresetL( TInt aId )

   279     {

   280     PS_PRINT_DATABASE;

   281 

   282     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   283 

   284     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsTable().Length() + KPSPresetsDataHandlerColumn().Length() +

   285                                   KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   286     sqlBuf->Des().Format( sql, &KPSPresetsDataHandlerColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   287 

   288     RDbView view;

   289     User::LeaveIfError( view.Prepare( *this, *sqlBuf ) );

   290     CleanupStack::PopAndDestroy( sqlBuf );

   291     CleanupClosePushL( view );

   292 

   293     User::LeaveIfError( view.EvaluateAll() );

   294 

   295     if ( view.FirstL() )

   296         {

   297         view.GetL();

   298         CDbColSet* columns = view.ColSetL();

   299         TUid uid = TUid::Uid( view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) ) );

   300         delete columns;

   301         view.DeleteL();

   302         iObserver.HandlePresetChangedL( aId, uid, MPSPresetObserver::EPSDeleted );

   303         }

   304 

   305     CleanupStack::PopAndDestroy( &view );

   306 

   307     PS_PRINT_DATABASE;

   308     }

   309 

   310 // ---------------------------------------------------------------------------

   311 // Commits a preset to the database.

   312 // ---------------------------------------------------------------------------

   313 //

   314 void RPSDatabase::CommitPresetL( const CPSPendingPreset& aPreset )

   315     {

   316     PS_PRINT_DATABASE;

   317 

   318     _LIT( sql, "SELECT * FROM %S WHERE %S = %d" );

   319     

   320     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsTable().Length() + KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   321     sqlBuf->Des().Format( sql, &KPSPresetsTable, &KPSPresetsIdColumn, aPreset.Id() );

   322 

   323     RDbView view;

   324     User::LeaveIfError( view.Prepare( *this, *sqlBuf ) );

   325     CleanupStack::PopAndDestroy( sqlBuf );

   326     CleanupClosePushL( view );

   327 

   328     User::LeaveIfError( view.EvaluateAll() );

   329     

   330     if ( view.FirstL() )

   331         {

   332         CDbColSet* columns = view.ColSetL();

   333         CleanupStack::PushL( columns );

   334 

   335         view.UpdateL();

   336 

   337         RDbColWriteStream stream;

   338 

   339         stream.OpenLC( view, columns->ColNo( KPSPresetsNameColumn ) );

   340         stream.WriteL( aPreset.Name() );

   341         stream.CommitL();

   342 

   343         CleanupStack::PopAndDestroy( &stream );

   344 

   345         view.SetColL( columns->ColNo( KPSPresetsIndexColumn ), aPreset.Index() );

   346         

   347         stream.OpenLC( view, columns->ColNo( KPSPresetsDataColumn ) );

   348         stream.WriteL( aPreset.Data() );

   349         stream.CommitL();

   350         CleanupStack::PopAndDestroy( &stream );

   351 

   352         view.PutL();

   353 

   354         TUid uid = TUid::Uid( view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) ) );

   355 

   356         CleanupStack::PopAndDestroy( columns );

   357         

   358         iObserver.HandlePresetChangedL( aPreset.Id(), uid, MPSPresetObserver::EPSModified );

   359         }

   360 

   361     CleanupStack::PopAndDestroy( &view );

   362     

   363     PS_PRINT_DATABASE;

   364     }

   365 

   366 // ---------------------------------------------------------------------------

   367 // Moves a preset to the supplied index.

   368 // ---------------------------------------------------------------------------

   369 //

   370 void RPSDatabase::MovePresetL( TInt aId, TInt aDestinationIndex )

   371     {

   372     PS_PRINT_DATABASE;

   373 

   374     if ( aDestinationIndex < 0 )

   375         {

   376         User::Leave( KErrArgument );

   377         }

   378 

   379     // First, fetch the index and data handler of the preset that is about to be moved.

   380 

   381     _LIT( selectPreset, "SELECT %S, %S FROM %S WHERE %S = %d" );

   382     

   383     HBufC* selectPresetBuf = HBufC::NewLC( selectPreset().Length() + KPSPresetsIndexColumn().Length() + KPSPresetsDataHandlerColumn().Length() + 

   384                                            KPSPresetsTable().Length() + KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   385     

   386     selectPresetBuf->Des().Format( selectPreset, &KPSPresetsIndexColumn, &KPSPresetsDataHandlerColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   387     

   388     RDbView view;

   389     User::LeaveIfError( view.Prepare( *this, *selectPresetBuf, RDbView::EReadOnly ) );

   390     CleanupStack::PopAndDestroy( selectPresetBuf );

   391     CleanupClosePushL( view );

   392     

   393     if ( !view.FirstL() )

   394         {

   395         User::Leave( KErrNotFound );

   396         }

   397 

   398     view.GetL();

   399     CDbColSet* columns = view.ColSetL();

   400     TInt sourceIndex = view.ColInt32( columns->ColNo( KPSPresetsIndexColumn ) );

   401     TUid dataHandler = TUid::Uid( view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) ) );

   402     delete columns;

   403     CleanupStack::PopAndDestroy( &view );

   404 

   405     TInt minIndex = Min( sourceIndex, aDestinationIndex );

   406     TInt maxIndex = Max( sourceIndex, aDestinationIndex );

   407     

   408     TBool direction = ( aDestinationIndex > sourceIndex ); // EFalse means that the preset is to be moved up, ETrue means that it is to be moved down.

   409 

   410     _LIT( asc, "ASC" );

   411     _LIT( desc, "DESC" );

   412 

   413     TPtrC sortPtr( direction ? desc() : asc() );

   414     

   415     // Selects all preset in between the source and destination indices.

   416      _LIT( sql, "SELECT * FROM %S WHERE %S >= %d AND %S <= %d AND %S = %d ORDER BY %S %S" );

   417     

   418     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsIndexColumn().Length() * 3 + KPSPresetsTable().Length() +

   419                                   KPSPresetsDataHandlerColumn().Length() + sortPtr.Length() + KDefaultRealWidth * 3 );

   420 

   421     sqlBuf->Des().Format( sql, &KPSPresetsTable, &KPSPresetsIndexColumn, minIndex, &KPSPresetsIndexColumn,

   422                           maxIndex, &KPSPresetsDataHandlerColumn, dataHandler.iUid, &KPSPresetsIndexColumn, &sortPtr );

   423 

   424     User::LeaveIfError( view.Prepare( *this, *sqlBuf ) );

   425     CleanupStack::PopAndDestroy( sqlBuf );

   426     CleanupClosePushL( view );

   427 

   428     User::LeaveIfError( view.EvaluateAll() );

   429 

   430     TInt lastIndex = aDestinationIndex;

   431 

   432     if ( view.LastL() ) // Handle the preset that is to be moved first.    

   433         {

   434         view.GetL();

   435         view.UpdateL();

   436         

   437         columns = view.ColSetL();

   438         CleanupStack::PushL( columns );

   439         

   440         view.SetColL( columns->ColNo( KPSPresetsIndexColumn ), aDestinationIndex );

   441         view.PutL();

   442         

   443         iObserver.HandlePresetChangedL( view.ColInt32( columns->ColNo( KPSPresetsIdColumn ) ),

   444                                         TUid::Uid( view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) ) ),

   445                                         MPSPresetObserver::EPSModified );

   446 

   447         view.FirstL(); // Start iterating the presets from the beginning (the last element is always the preset that is to be moved).

   448 

   449         for ( TInt i = 0; i < view.CountL() - 1; i++ ) // The preset that was moved has already been handled.

   450             {

   451             view.GetL();

   452             view.UpdateL();

   453             

   454             TInt index = view.ColInt32( columns->ColNo( KPSPresetsIndexColumn ) );

   455 

   456             if ( lastIndex != index )

   457                 {

   458                 // If there was no preset with the index that the previous preset was moved to, there's no need to continue.

   459                 /*lint -save -e960 (Note -- Violates MISRA Required Rule 58, non-switch break used)*/

   460                 break;

   461                 /*lint -restore*/

   462                 }

   463             else 

   464                 {

   465                 // Preset was moved on top of another preset, continue iterating through the presets.

   466                 index += direction ? -1 : 1; // If moving up, all preset indices are incremented by one, otherwise they are decremented by one.

   467                 lastIndex = index;

   468                 view.SetColL( columns->ColNo( KPSPresetsIndexColumn ), index );

   469                 view.PutL();

   470 

   471                 iObserver.HandlePresetChangedL( view.ColInt32( columns->ColNo( KPSPresetsIdColumn ) ),

   472                                                 TUid::Uid( view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) ) ),

   473                                                 MPSPresetObserver::EPSModified );

   474                 }

   475 

   476             view.NextL();

   477             }

   478         

   479         CleanupStack::PopAndDestroy( columns );

   480         }

   481 

   482     CleanupStack::PopAndDestroy( &view );

   483 

   484     PS_PRINT_DATABASE;

   485     }

   486 

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

   488 // Returns the name of a preset.

   489 // ---------------------------------------------------------------------------

   490 //

   491 HBufC* RPSDatabase::PresetNameL( TInt aId )

   492     {

   493     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   494 

   495     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsNameColumn().Length() + KPSPresetsTable().Length() +

   496                                   KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   497 

   498     sqlBuf->Des().Format( sql, &KPSPresetsNameColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   499 

   500     RDbView view;

   501     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   502     CleanupStack::PopAndDestroy( sqlBuf );

   503     CleanupClosePushL( view );

   504 

   505     TInt nameLength = PresetNameLengthL( aId );

   506     HBufC* name = HBufC::NewLC( nameLength );

   507 

   508     if ( view.FirstL() )

   509         {

   510     

   511         view.GetL();

   512         CDbColSet* columns = view.ColSetL();

   513         TInt nameColumn = columns->ColNo( KPSPresetsNameColumn );

   514         delete columns;

   515 

   516         RDbColReadStream stream;

   517         TPtr namePtr = name->Des();

   518         stream.OpenLC( view, nameColumn );

   519         stream.ReadL( namePtr, nameLength );

   520         CleanupStack::PopAndDestroy( &stream);

   521         }

   522     else

   523         {

   524         User::Leave( KErrNotFound );

   525         }

   526     

   527     CleanupStack::Pop( name );    

   528     CleanupStack::PopAndDestroy( &view );

   529 

   530     return name;

   531     }

   532 

   533 // ---------------------------------------------------------------------------

   534 // Returns the length of the name field for a preset.

   535 // ---------------------------------------------------------------------------

   536 //

   537 TInt RPSDatabase::PresetNameLengthL( TInt aId )

   538     {

   539     return ColumnLengthL( KPSPresetsNameColumn, aId );

   540     }

   541 

   542 // ---------------------------------------------------------------------------

   543 // Returns the index of a preset.

   544 // ---------------------------------------------------------------------------

   545 //

   546 TInt RPSDatabase::PresetIndexL( TInt aId )

   547     {

   548     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   549 

   550     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsIndexColumn().Length() + KPSPresetsTable().Length() +

   551                                   KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   552 

   553     sqlBuf->Des().Format( sql, &KPSPresetsIndexColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   554 

   555     RDbView view;

   556     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   557     CleanupStack::PopAndDestroy( sqlBuf );

   558     CleanupClosePushL( view );

   559 

   560     TInt index = KErrNotFound;

   561 

   562     if ( view.FirstL() )

   563         {

   564         view.GetL();

   565         CDbColSet* columns = view.ColSetL();

   566         index = view.ColInt32( columns->ColNo( KPSPresetsIndexColumn ) );

   567         delete columns;

   568         }

   569     else

   570         {

   571         User::Leave( KErrNotFound );

   572         }

   573         

   574     CleanupStack::PopAndDestroy( &view );

   575 

   576     return index;

   577     }

   578 

   579 // ---------------------------------------------------------------------------

   580 // Returns the data handler of a preset.

   581 // ---------------------------------------------------------------------------

   582 //

   583 TUid RPSDatabase::PresetDataHandlerL( TInt aId )

   584     {

   585     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   586 

   587     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsDataHandlerColumn().Length() + KPSPresetsTable().Length() +

   588                                   KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   589 

   590     sqlBuf->Des().Format( sql, &KPSPresetsDataHandlerColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   591 

   592     RDbView view;

   593     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   594     CleanupStack::PopAndDestroy( sqlBuf );

   595     CleanupClosePushL( view );

   596 

   597     TUid dataHandler = KNullUid;

   598 

   599     if ( view.FirstL() )

   600         {

   601         view.GetL();

   602         CDbColSet* columns = view.ColSetL();

   603         dataHandler.iUid = view.ColInt32( columns->ColNo( KPSPresetsDataHandlerColumn ) );

   604         delete columns;

   605         }

   606     else

   607         {

   608         User::Leave( KErrNotFound );

   609         }

   610         

   611     CleanupStack::PopAndDestroy( &view );

   612 

   613     return dataHandler;

   614     }

   615 

   616 // ---------------------------------------------------------------------------

   617 // Returns the binary data of a preset.

   618 // ---------------------------------------------------------------------------

   619 //

   620 HBufC8* RPSDatabase::PresetDataL( TInt aId )

   621     {

   622     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   623 

   624     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + KPSPresetsDataColumn().Length() + KPSPresetsTable().Length() +

   625                                   KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   626 

   627     sqlBuf->Des().Format( sql, &KPSPresetsDataColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   628 

   629     RDbView view;

   630     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   631     CleanupStack::PopAndDestroy( sqlBuf );

   632     CleanupClosePushL( view );

   633 

   634     HBufC8* data = NULL;

   635 

   636     if ( view.FirstL() )

   637         {

   638         view.GetL();

   639         CDbColSet* columns = view.ColSetL();

   640         TInt columnNo = columns->ColNo( KPSPresetsDataColumn );

   641         delete columns;

   642         

   643         data = HBufC8::NewLC( view.ColLength( columnNo ) );

   644         TPtr8 ptr( data->Des() );

   645         

   646         RDbColReadStream stream;

   647         stream.OpenLC( view, columnNo );

   648         stream.ReadL( ptr, view.ColLength( columnNo ) );

   649         CleanupStack::PopAndDestroy( &stream );

   650         CleanupStack::Pop( data );

   651         }

   652     else

   653         {

   654         User::Leave( KErrNotFound );

   655         }

   656         

   657     CleanupStack::PopAndDestroy( &view );

   658 

   659     return data;

   660     }

   661 

   662 // ---------------------------------------------------------------------------

   663 // Returns the length of the binary data of a preset.

   664 // ---------------------------------------------------------------------------

   665 //

   666 TInt RPSDatabase::PresetDataLengthL( TInt aId )

   667     {

   668     return ColumnLengthL( KPSPresetsDataColumn, aId );

   669     }

   670 

   671 // ---------------------------------------------------------------------------

   672 // Returns the current database version number.

   673 // ---------------------------------------------------------------------------

   674 //

   675 TInt RPSDatabase::CurrentDatabaseVersionL()

   676     {

   677     TInt version = 0;

   678 

   679     RDbTable table;

   680     TInt err = table.Open( *this, KPSVersionsTable, RDbTable::EReadOnly );

   681     

   682     if ( err != KErrNotFound )

   683         {

   684         User::LeaveIfError( err );

   685 

   686         CleanupClosePushL( table );

   687 

   688         if ( table.FirstL() )

   689             {

   690             table.GetL();

   691 

   692             CDbColSet* columns = table.ColSetL();

   693             version = table.ColInt32( columns->ColNo( KPSVersionsVersionColumn ) );

   694             delete columns;

   695             }

   696 

   697         CleanupStack::PopAndDestroy( &table );

   698         }

   699 

   700     return version;

   701     }

   702 

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

   704 // Updates the database version number.

   705 // ---------------------------------------------------------------------------

   706 //

   707 void RPSDatabase::UpdateDatabaseVersionL( TInt aVersion )

   708     {

   709     RDbTable table;

   710     User::LeaveIfError( table.Open( *this, KPSVersionsTable ) );

   711     CleanupClosePushL( table );

   712     

   713     CDbColSet* columns = table.ColSetL();

   714     CleanupStack::PushL( columns );

   715 

   716     table.Reset();

   717     table.FirstL() ? table.UpdateL() : table.InsertL(); // If a row exists open it for update, otherwise create a new one.

   718     table.SetColL( columns->ColNo( KPSVersionsVersionColumn ), aVersion );

   719     table.PutL();

   720 

   721     CleanupStack::PopAndDestroy( 2, &table );

   722     }

   723 

   724 // ---------------------------------------------------------------------------

   725 // Updates the whole database to the latest version.

   726 // ---------------------------------------------------------------------------

   727 //

   728 void RPSDatabase::UpdateDatabaseL()

   729     {

   730     TInt currentVersion = CurrentDatabaseVersionL();

   731 

   732     if ( currentVersion < KPSDatabaseVersion )

   733         {

   734         for ( TInt i = currentVersion; i < KPSDatabaseVersion; i++ )

   735             {

   736             ((*this).*iDatabaseUpdateFunctions[i])(); // All of these function calls can leave.

   737             }

   738         }

   739     }

   740 

   741 // ---------------------------------------------------------------------------

   742 // Creates the tables.

   743 // ---------------------------------------------------------------------------

   744 //

   745 void RPSDatabase::CreateTablesL()

   746     {

   747     // Creates the preset table.

   748     TDbCol presetsIdColumn( KPSPresetsIdColumn, EDbColInt32 );

   749     presetsIdColumn.iAttributes = TDbCol::EAutoIncrement;

   750 

   751     CDbColSet* columns = CDbColSet::NewLC();

   752     columns->AddL( presetsIdColumn );

   753     columns->AddL( TDbCol( KPSPresetsNameColumn, EDbColLongText ) );

   754     columns->AddL( TDbCol( KPSPresetsIndexColumn, EDbColInt32 ) );

   755     columns->AddL( TDbCol( KPSPresetsDataHandlerColumn, EDbColInt32 ) );

   756     columns->AddL( TDbCol( KPSPresetsDataColumn, EDbColLongText8 ) );

   757 

   758     User::LeaveIfError( CreateTable( KPSPresetsTable, *columns ) );

   759     

   760     CleanupStack::PopAndDestroy( columns );

   761 

   762     // This is a hack to circumvent problems with Publish & Subscribe, as it initializes all data properties to zero,

   763     // causing a notification to fire with the value of zero. This is the reason why most users of the API have defined

   764     // zero to be the uninitialized state of the property. The problem caused by this is that the DBMS API's auto increment

   765     // field starts from zero, and should there exist a preset with such an ID, it could not be properly conveyed to the

   766     // interested parties. Thus, we will make a dummy preset now that the preset table is created and remove it instantly,

   767     // thereby making the auto increment column to start from one instead of zero.

   768     

   769     _LIT( selectAll, "SELECT * FROM %S" );

   770 

   771     HBufC* sqlBuf = HBufC::NewLC( selectAll().Length() + KPSPresetsTable().Length() );

   772     sqlBuf->Des().Format( selectAll, &KPSPresetsTable );

   773     

   774     RDbView view;

   775     User::LeaveIfError( view.Prepare( *this, *sqlBuf ) );

   776     CleanupStack::PopAndDestroy( sqlBuf );

   777     CleanupClosePushL( view );

   778     User::LeaveIfError( view.EvaluateAll() );

   779 

   780     view.FirstL();    

   781     view.InsertL();

   782     view.PutL();

   783     view.DeleteL();

   784 

   785     CleanupStack::PopAndDestroy( &view );

   786 

   787     // Creates the version table.

   788     columns = CDbColSet::NewLC();

   789     columns->AddL( TDbCol( KPSVersionsVersionColumn, EDbColInt32 ) );

   790     

   791     User::LeaveIfError( CreateTable( KPSVersionsTable, *columns ) );

   792     

   793     CleanupStack::PopAndDestroy( columns );

   794     

   795     UpdateDatabaseVersionL( KPSDatabaseVersion1 ); // Version 1 of the database successfully created.

   796     }

   797 

   798 // ---------------------------------------------------------------------------

   799 // Returns the length of a column.

   800 // ---------------------------------------------------------------------------

   801 //

   802 TInt RPSDatabase::ColumnLengthL( const TDesC& aColumn, TInt aId )

   803     {

   804     _LIT( sql, "SELECT %S FROM %S WHERE %S = %d" );

   805 

   806     TInt length = KErrNotFound;

   807 

   808     HBufC* sqlBuf = HBufC::NewLC( sql().Length() + aColumn.Length() + KPSPresetsTable().Length() + KPSPresetsIdColumn().Length() + KDefaultRealWidth );

   809     sqlBuf->Des().Format( sql, &aColumn, &KPSPresetsTable, &KPSPresetsIdColumn, aId );

   810 

   811     RDbView view;

   812     User::LeaveIfError( view.Prepare( *this, *sqlBuf, RDbView::EReadOnly ) );

   813     CleanupStack::PopAndDestroy( sqlBuf );

   814     CleanupClosePushL( view );

   815 

   816     if ( view.FirstL() )

   817         {

   818         view.GetL();

   819         CDbColSet* columns = view.ColSetL();

   820         length = view.ColLength( columns->ColNo( aColumn ) );

   821         delete columns;

   822         }

   823     else

   824         {

   825         User::Leave( KErrNotFound );

   826         }

   827         

   828     CleanupStack::PopAndDestroy( &view );

   829 

   830     return length;

   831     }

   832     

   833 // ---------------------------------------------------------------------------

   834 // Debug method that prints the contents of the database.

   835 // ---------------------------------------------------------------------------

   836 //

   837 void RPSDatabase::PrintDatabaseL()

   838     {

   839     PSDEBUG( "RPSDatabase::PrintDatabaseL() - Versions:" );

   840 

   841     RDbTable table;

   842     TInt err = table.Open( *this, KPSVersionsTable, RDbTable::EReadOnly );

   843     

   844     if ( err == KErrNotFound )

   845         {

   846         PSDEBUG( "\tYarr, thar database be not in this world, mate!" );

   847         }

   848     else

   849         {

   850         User::LeaveIfError( err );

   851 

   852         CleanupClosePushL( table );

   853 

   854         if ( table.FirstL() )

   855             {

   856             CDbColSet* columns = table.ColSetL();

   857             TInt versionColumn = columns->ColNo( KPSVersionsVersionColumn );

   858             delete columns;

   859             

   860             do  

   861                 {

   862                 table.GetL();

   863                 PSDEBUG2( "\t%d", table.ColInt32( versionColumn ) );

   864                 } while ( table.NextL() );

   865             }

   866         else

   867             {

   868             PSDEBUG( "\tYarr, thar table be empty!" );

   869             }

   870 

   871         CleanupStack::PopAndDestroy( &table );

   872         }

   873     

   874     PSDEBUG( "RPSDatabase::PrintDatabaseL() - Presets:" );

   875 

   876     err = table.Open( *this, KPSPresetsTable, RDbTable::EReadOnly );

   877     

   878     if ( err == KErrNotFound )

   879         {

   880         PSDEBUG( "\tYarr, thar database be not in this world, mate!" );

   881         }

   882     else

   883         {

   884         User::LeaveIfError( err );

   885         

   886         CleanupClosePushL( table );

   887 

   888 		if ( table.FirstL() )

   889 		    {

   890             CDbColSet* columns = table.ColSetL();

   891             TInt idColumn = columns->ColNo( KPSPresetsIdColumn );

   892             TInt dataHandlerColumn = columns->ColNo( KPSPresetsDataHandlerColumn );

   893             TInt indexColumn = columns->ColNo( KPSPresetsIndexColumn );

   894             TInt nameColumn = columns->ColNo( KPSPresetsNameColumn );

   895             delete columns;

   896             

   897             do  

   898                 {

   899                 table.GetL();

   900                 // stream is needed for long columns

   901                 RDbColReadStream stream;

   902                 TInt nameLength = PresetNameLengthL( table.ColInt32( idColumn ) );

   903                 HBufC* name = HBufC::NewLC( nameLength );

   904                 TPtr namePtr = name->Des();

   905                 stream.OpenLC( table, nameColumn );

   906                 stream.ReadL( namePtr, nameLength );

   907 

   908                 CleanupStack::PopAndDestroy( &stream );

   909                 

   910                 PSDEBUG5( "\tId: %10u\tData Handler: 0x%x\tIndex: %10u\tName: %S", table.ColInt32( idColumn ), table.ColInt32( dataHandlerColumn ), table.ColInt32( indexColumn ), name );

   911                 

   912                 CleanupStack::PopAndDestroy( name );

   913                 } while ( table.NextL() );

   914 		    }

   915         else

   916             {

   917             PSDEBUG( "\tYarr, thar table be empty!" );

   918             }

   919     

   920         CleanupStack::PopAndDestroy( &table );

   921         }

   922     }

   923 

   924 // ======== GLOBAL FUNCTIONS ========