1 /*

     2 * Copyright (c) 2008 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:      SQLite Connection class

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 #include "cmdmsqliteconnection.h"

    24 #include "cmdmsqlclausedef.h"

    25 #include "cmfillrule.h"

    26 #include "cmfillrulecontainer.h"

    27 #include "cmmediaserverfull.h"

    28 #include "cmstorerule.h"

    29 #include "cmfilllistitem.h"

    30 #include "cmstorelistitem.h"

    31 #include "cmdriveinfo.h"

    32 #include "cmsearchresponsehash.h"

    33 #include "msdebug.h"

    34 

    35 // Constants

    36 _LIT8( KCmDbPragmaCacheSize, "PRAGMA cache_size=4096;PRAGMA page_size=4096;");

    37 const TUint8 KAmountOfIDs = 10;

    38 

    39 // ---------------------------------------------------------------------------

    40 // CCmDmSQLiteConnection::NewL

    41 // ---------------------------------------------------------------------------

    42 //

    43 CCmDmSQLiteConnection* CCmDmSQLiteConnection::NewL()

    44     {

    45     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::NewL()"));

    46     

    47     CCmDmSQLiteConnection* self = CCmDmSQLiteConnection::NewLC();

    48     CleanupStack::Pop( self );

    49 

    50     return self;

    51     }

    52  

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

    54 // CCmDmSQLiteConnection::NewLC

    55 // ---------------------------------------------------------------------------

    56 //    

    57 CCmDmSQLiteConnection* CCmDmSQLiteConnection::NewLC()

    58     {

    59     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::NewLC()"));

    60     

    61     CCmDmSQLiteConnection* self = new ( ELeave ) CCmDmSQLiteConnection();

    62     CleanupStack::PushL( self );

    63     self->ConstructL();

    64 

    65     return self;  

    66     }    

    67 

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

    69 // CCmDmSQLiteConnection::~CCmDmSQLiteConnection

    70 // ---------------------------------------------------------------------------

    71 //

    72 CCmDmSQLiteConnection::~CCmDmSQLiteConnection()

    73     {

    74     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::~CCmDmSQLiteConnection()"));

    75     

    76     TRAP_IGNORE( BackUpIdL( ERuleGroupID, iRuleGroupID ) );

    77     TRAP_IGNORE( BackUpIdL( ERuleID, iRuleID ) );

    78     TRAP_IGNORE( BackUpIdL( ERuleParamID, iRuleParamID ) );

    79     TRAP_IGNORE( BackUpIdL( EMediaServerID, iMediaServerID ) );

    80     TRAP_IGNORE( BackUpIdL( EStoredID, iStoredID ) );

    81     TRAP_IGNORE( BackUpIdL( EFilledID, iFilledID ) );

    82     TRAP_IGNORE( BackUpIdL( EStoreRuleID, iStoreRuleID ) );

    83     TRAP_IGNORE( BackUpIdL( EStoreRuleParamID, iStoreRuleParamID ) );

    84     TRAP_IGNORE( BackUpIdL( EFillFileListId, iFillFileId ) );

    85     TRAP_IGNORE( BackUpIdL( EStoreFileListId, iStoreFileId ) );

    86     CloseDb();

    87     }

    88 

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

    90 // CCmDmSQLiteConnection::OpenDb

    91 // ---------------------------------------------------------------------------

    92 //

    93 TInt CCmDmSQLiteConnection::OpenDb( const TDesC& aDb )

    94     {

    95     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::OpenDb()"));

    96     

    97     TInt err( iDatabase.Open( aDb, NULL ) );

    98     if ( err != KErrNone )

    99         {

   100         TRACE(Print(_L("[DATABASE MANAGER]\t CCmDmSQLiteConnection::OpenDb()\

   101          error %d"), err));

   102         }

   103     else 

   104         {

   105         err = iDatabase.Exec( KCmDbPragmaCacheSize );        

   106         

   107         }

   108     return err;

   109     }

   110 

   111 // ---------------------------------------------------------------------------

   112 // CCmDmSQLiteConnection::CloseDb

   113 // ---------------------------------------------------------------------------

   114 //

   115 void CCmDmSQLiteConnection::CloseDb()

   116     {

   117     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::CloseDb()"));

   118     

   119     iDatabase.Close();         

   120     }

   121 

   122 // ---------------------------------------------------------------------------

   123 // CCmDmSQLiteConnection::InitIDs

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

   125 //

   126 void CCmDmSQLiteConnection::InitIDs()

   127     {

   128     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::InitIDs()"));

   129     

   130     TInt err = iStatement.Prepare( iDatabase, KAddIDs );

   131     if( err )

   132         {

   133         TRACE(Print(_L("[DATABASE MANAGER]\t \

   134             CCmDmSQLiteConnection::SetIDs() FAILED ")));

   135         }

   136     else

   137         {

   138         for( TInt j=1; j <= KAmountOfIDs ; j++ )

   139             {    

   140             SetID( static_cast<TTypeOfID>(j) );

   141             }

   142         iStatement.Close();        

   143         }          

   144     }

   145 

   146 // ---------------------------------------------------------------------------

   147 // CCmDmSQLiteConnection::SetID

   148 // ---------------------------------------------------------------------------

   149 //    

   150 void CCmDmSQLiteConnection::SetID( TTypeOfID aType )

   151     {

   152     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetID()"));

   153     

   154     // Init all ids to one    

   155     iStatement.BindInt64( 0, 1 );

   156     iStatement.BindInt( 1, aType );

   157     iStatement.Exec();

   158     iStatement.Reset();        

   159     }

   160 

   161 // ---------------------------------------------------------------------------

   162 // CCmDmSQLiteConnection::BackUpIdL

   163 // ---------------------------------------------------------------------------

   164 //

   165 void CCmDmSQLiteConnection::BackUpIdL( TTypeOfID aType, TUint64 aID )

   166     {

   167     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::BackUpIdL()"));

   168     

   169     iStatement.PrepareL( iDatabase, KUpdateID );

   170     iStatement.BindInt64( 0, aID );

   171     iStatement.BindInt( 1, aType );

   172     iStatement.Exec();

   173     iStatement.Reset();

   174     iStatement.Close();

   175     }

   176         

   177 // ---------------------------------------------------------------------------

   178 // CCmDmSQLiteConnection::LoadIDs

   179 // ---------------------------------------------------------------------------

   180 //

   181 void CCmDmSQLiteConnection::LoadIDs()

   182     {    

   183     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::LoadIDs()"));

   184     

   185     TRAP_IGNORE( LoadIDL( iRuleGroupID, ERuleGroupID ) );

   186     TRAP_IGNORE( LoadIDL( iRuleID, ERuleID ) );

   187     TRAP_IGNORE( LoadIDL( iRuleParamID, ERuleParamID ) );

   188     TRAP_IGNORE( LoadIDL( iMediaServerID, EMediaServerID ) );

   189     TRAP_IGNORE( LoadIDL( iStoredID, EStoredID ) );

   190     TRAP_IGNORE( LoadIDL( iFilledID, EFilledID ) );

   191     TRAP_IGNORE( LoadIDL( iStoreRuleID, EStoreRuleID ) );

   192     TRAP_IGNORE( LoadIDL( iStoreRuleParamID, EStoreRuleParamID ) );

   193     TRAP_IGNORE( LoadIDL( iFillFileId, EFillFileListId) );

   194     TRAP_IGNORE( LoadIDL( iStoreFileId, EStoreFileListId) );       

   195     }

   196 

   197 // ---------------------------------------------------------------------------

   198 // CCmDmSQLiteConnection::LoadIDL

   199 // ---------------------------------------------------------------------------

   200 //

   201 void CCmDmSQLiteConnection::LoadIDL( TUint64& aId, TTypeOfID aType )

   202     {

   203     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::LoadIDL()"));

   204     

   205     TInt err = iStatement.Prepare( iDatabase, KSelectID );

   206     if( err )

   207             {

   208             TRACE(Print(_L("[DATABASE MANAGER]\t \

   209                 CCmDmSQLiteConnection::LoadIDL() FAILED ")));

   210             User::Leave( err );

   211             }

   212     else

   213         {

   214         iStatement.BindInt( 0, aType );

   215         

   216         // get id

   217         err = iStatement.Next();

   218         if (  err == KSqlAtRow )  

   219             {

   220             aId = iStatement.ColumnInt64( 0 );

   221             }

   222         iStatement.Reset();

   223         iStatement.Close();                    

   224         }            

   225     }

   226 

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

   228 // CCmDmSQLiteConnection::CreateDbFile

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

   230 //

   231 TInt CCmDmSQLiteConnection::CreateDbFile( const TDesC& aDb )

   232     {

   233     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::CreateDbFile()"));

   234     

   235     TInt err( iDatabase.Create( aDb ) );

   236     return err;

   237     }

   238     

   239 // ---------------------------------------------------------------------------

   240 // CCmDmSQLiteConnection::Validate

   241 // ---------------------------------------------------------------------------

   242 //

   243 TBool CCmDmSQLiteConnection::Validate()

   244     {

   245     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::Validate()"));

   246     

   247     TInt ret( KErrNone );

   248     TInt err = iStatement.Prepare( iDatabase, 

   249         KValidateTableExistence );

   250     // Loop only one row in results

   251     if( err )

   252         {

   253         ret = KErrGeneral;

   254         }

   255     else

   256         {

   257         err = iStatement.Next();    

   258         if ( err != KSqlAtRow )  

   259             {

   260             ret = KErrGeneral;       

   261             }

   262         iStatement.Reset();

   263         iStatement.Close();          

   264         }                     

   265     TBool retval = EFalse;

   266     if ( ret == KErrNone ) 

   267         {

   268         retval = ETrue;

   269         }

   270     return retval;

   271     }

   272     

   273 // ---------------------------------------------------------------------------

   274 // CCmDmSQLiteConnection::ExecuteL

   275 // ---------------------------------------------------------------------------

   276 //

   277 void CCmDmSQLiteConnection::ExecuteL( const TDesC8& aCommand )

   278     {

   279     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::ExecuteL()"));

   280     

   281     TInt err( iDatabase.Exec( aCommand ) );

   282     if ( KErrNone > err  )

   283         {

   284         User::Leave( err );    

   285         }    

   286     }

   287 

   288 // ---------------------------------------------------------------------------

   289 // CCmDmSQLiteConnection::SetFillFiles

   290 // ---------------------------------------------------------------------------

   291 //    

   292 TInt CCmDmSQLiteConnection::SetFillFiles( 

   293     RPointerArray<CCmFillListItem>& aItems )

   294     {

   295     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetFillFiles()"));

   296     

   297     iDatabase.Exec( KCmDbBeginTransaction );

   298     TInt err(KErrNone);

   299     for( TInt i = 0; i < aItems.Count(); i++ )

   300         {

   301         err = iStatement.Prepare( iDatabase, KAddFillFile );

   302         if( err )

   303             {

   304             TRACE(Print(_L("[DATABASE MANAGER]\t Prepare err = %d"), err ));

   305             }

   306         else

   307             {

   308             iStatement.BindInt64( 0, aItems[i]->DbId() );  

   309             iStatement.BindText( 1, aItems[i]->PrimaryText() );

   310             iStatement.BindText( 2, 

   311                 aItems[i]->SecondaryText() );

   312             iStatement.BindText( 3, aItems[i]->Path() );

   313             iStatement.BindBinary( 4, aItems[i]->Uri() );

   314             iStatement.BindBinary( 5, aItems[i]->ItemId() );

   315             iStatement.BindText( 6, aItems[i]->UpnpClass() );

   316             iStatement.BindInt( 7, aItems[i]->MediaType() );

   317             iStatement.BindInt( 8, aItems[i]->Priority() );

   318             iStatement.BindInt( 9, aItems[i]->Size() );

   319             iStatement.BindInt( 10, aItems[i]->Status() );

   320             iStatement.BindInt64( 11, aItems[i]->Date().Int64() );

   321             iStatement.BindInt( 12, aItems[i]->ListId() );

   322             iStatement.BindInt( 13, aItems[i]->DevId() );

   323             iStatement.BindInt64( 14, aItems[i]->RefId() );

   324             iStatement.BindInt( 15, aItems[i]->Selected() );

   325             iStatement.BindInt64( 16, aItems[i]->DriveId() );

   326             iStatement.BindInt( 17, aItems[i]->DriveNumber() );

   327             iStatement.Exec();

   328             iStatement.Reset();  

   329             iStatement.Close();        

   330             }            

   331         }

   332     iDatabase.Exec( KCmDbSqlCommit );

   333     return err;

   334     }

   335     

   336 // ---------------------------------------------------------------------------

   337 // CCmDmSQLiteConnection::SetStoreFilesL

   338 // ---------------------------------------------------------------------------

   339 //    

   340 TInt CCmDmSQLiteConnection::SetStoreFilesL( 

   341     RPointerArray<CCmStoreListItem>& aItems )

   342     {

   343     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetStoreFilesL()"));

   344     

   345     iDatabase.Exec( KCmDbBeginTransaction );

   346     TInt err(KErrNone);

   347     for( TInt i = 0; i < aItems.Count(); i++ )

   348         {

   349         err = iStatement.Prepare( iDatabase, KAddStoreFile );

   350         if( err )

   351             {

   352             err = KErrGeneral;

   353             }

   354         else

   355             {   

   356             iStatement.BindInt64( 0, iStoreFileId );

   357             iStatement.BindText( 1, aItems[i]->PrimaryText() );

   358             iStatement.BindText( 2, 

   359                 aItems[i]->SecondaryText() );

   360             iStatement.BindText( 3, aItems[i]->Path() );

   361             iStatement.BindInt( 4, aItems[i]->Size() );

   362             iStatement.BindInt64( 5, aItems[i]->Date().Int64() );

   363             iStatement.BindInt( 6, aItems[i]->ListId() );

   364             iStatement.Exec();

   365             iStatement.Reset();

   366             iStatement.Close();            

   367             }    

   368         /** INSERT Server */

   369         RArray<TInt> serverIds( aItems[i]->DevIds() );

   370         RArray<TCmListItemStatus> statusValues( aItems[i]->StatusValues() );

   371         for( TInt j = 0; j < serverIds.Count(); j++ )

   372             {

   373             err = iStatement.Prepare( iDatabase, KAddStoreFileServer );

   374             if( err )

   375                 {

   376                 err = KErrGeneral;

   377                 }

   378             else

   379                 {

   380                 iStatement.BindInt64( 0, iStoreFileId );

   381                 iStatement.BindInt( 1, serverIds[j] );

   382                 iStatement.BindInt( 2, statusValues[j] );

   383                 iStatement.Exec();

   384                 iStatement.Reset();

   385                 iStatement.Close();            

   386                 }            

   387             }

   388         iStoreFileId++;                        

   389         }

   390     iDatabase.Exec( KCmDbSqlCommit );

   391     BackUpIdL( EStoreFileListId, iStoreFileId );

   392     return err;

   393     }

   394     

   395 // ---------------------------------------------------------------------------

   396 // CCmDmSQLiteConnection::AddStoreFile

   397 // ---------------------------------------------------------------------------

   398 //

   399 TInt CCmDmSQLiteConnection::AddStoreFile( CCmStoreListItem& aItem )

   400     {

   401     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoreFile()"));

   402     

   403     TInt err(KErrNone);

   404     err = iStatement.Prepare( iDatabase, KAddStoreFile );

   405     if( err )

   406         {

   407         err = KErrGeneral;

   408         }

   409     else

   410         {

   411         iStatement.BindInt64( 0, iStoreFileId );

   412         iStatement.BindText( 1, aItem.PrimaryText() );

   413         iStatement.BindText( 2, aItem.SecondaryText() );

   414         iStatement.BindText( 3, aItem.Path() );

   415         iStatement.BindInt( 4, aItem.Size() );

   416         iStatement.BindInt64( 5, aItem.Date().Int64() );

   417         iStatement.BindInt64( 6, aItem.ListId() );            

   418         iStatement.Exec();

   419         iStatement.Reset();

   420         iStatement.Close();

   421         /** INSERT Server */

   422         RArray<TInt>serverIds( aItem.DevIds() );

   423         RArray<TCmListItemStatus>statusValues( aItem.StatusValues() );        

   424         for( TInt j = 0; j < serverIds.Count() ; j++ )

   425             {

   426             err = iStatement.Prepare( iDatabase, KAddStoreFileServer );

   427             if( err )

   428                 {

   429                 err = KErrGeneral;

   430                 }

   431             else

   432                 {

   433                 iStatement.BindInt64( 0, iStoreFileId );

   434                 iStatement.BindInt( 1, serverIds[j] );

   435                 iStatement.BindInt( 2, statusValues[j] );

   436                 iStatement.Exec();

   437                 iStatement.Reset();

   438                 iStatement.Close();            

   439                 }            

   440             }                

   441         }

   442     iStoreFileId++;            

   443     return err;

   444     }

   445             

   446 // ---------------------------------------------------------------------------

   447 // CCmDmSQLiteConnection::AddStoredL

   448 // ---------------------------------------------------------------------------

   449 //

   450 TInt CCmDmSQLiteConnection::AddStoredL( 

   451     const TDesC& aFileName, 

   452     const TDesC8& aUDN, 

   453     TTime aTimeStamp )

   454     {

   455     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoredL()"));

   456     /* FIRST QYERY MediaServerID from the MediaServer table

   457     using UDN */

   458     TInt err = iStatement.Prepare( iDatabase, KSelectMediaServerIDByUDN ) ;

   459     TUint64 mediaServerID(0);    

   460     if( err )

   461         {

   462         TRACE(Print(_L("[DATABASE MANAGER]\t KSelectMediaServerIDByUDN \

   463             FAILED ")));

   464         err = KErrGeneral;

   465         }

   466     else

   467         {

   468         iStatement.BindBinary( 0, aUDN );

   469         // Loop only one row in results

   470         err = iStatement.Next();

   471         if ( err == KSqlAtRow )  

   472             {

   473             // Get cell contents    

   474             mediaServerID = iStatement.ColumnInt64( 0 );

   475             iStatement.Reset();            

   476             iStatement.Close();  // Destruct statement  

   477             err = KErrNone;          

   478             }        

   479         }

   480             

   481     err = iStatement.Prepare( iDatabase, KAddStored );

   482     if( err )

   483         {

   484         TRACE(Print(_L("[DATABASE MANAGER]\t KAddStored FAILED ")));

   485         err = KErrGeneral;

   486         }

   487     else

   488         {

   489         iStatement.BindInt64( 0, iStoredID );

   490         iStatement.BindText( 1, aFileName );          

   491         iStatement.BindInt64( 2, mediaServerID );    

   492         iStatement.BindInt64( 3, aTimeStamp.Int64() );

   493         iStatement.Exec();

   494         iStatement.Reset();

   495         iStatement.Close();

   496         err = KErrNone;   

   497         }

   498     iStoredID++;

   499     BackUpIdL( EStoredID, iStoredID );                

   500 

   501     return err;    

   502     }

   503 

   504 // ---------------------------------------------------------------------------

   505 // CCmDmSQLiteConnection::AddFillRuleL

   506 // ---------------------------------------------------------------------------

   507 //    

   508 TInt CCmDmSQLiteConnection::AddFillRuleL( CCmFillRule* aFillRule )

   509     {

   510     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddFillRuleL()"));

   511     

   512     iDatabase.Exec( KCmDbBeginTransaction );

   513     TInt err = iStatement.Prepare( iDatabase, KAddFillGroup );

   514     

   515     if ( err == KErrNone )

   516         {

   517         if( aFillRule->ListId() )

   518             {

   519             iRuleGroupID = aFillRule->ListId();

   520             }

   521         iStatement.BindInt64( 0, iRuleGroupID );        

   522         iStatement.BindBinary( 1, aFillRule->Name() );

   523         iStatement.BindInt( 2, aFillRule->Method() );

   524         iStatement.BindInt( 3, aFillRule->LimitType() );

   525         iStatement.BindInt( 4, aFillRule->Amount() );

   526         iStatement.BindInt( 5, aFillRule->Selected() );

   527         iStatement.BindInt( 6, aFillRule->Priority() );

   528         iStatement.BindInt( 7, aFillRule->TemplateId() );

   529         iStatement.BindInt( 8, aFillRule->MediaType() );

   530         iStatement.BindInt( 9, aFillRule->Status() );

   531         iStatement.BindInt64( 10, aFillRule->ListRealCount() );

   532         iStatement.BindInt64( 11, aFillRule->ListRealSizeInBytes() );

   533         iStatement.Exec();

   534         iStatement.Reset();

   535         iStatement.Close();                

   536    

   537         err = AddFillRuleMediaServersL( aFillRule );

   538                 

   539         if ( err == KErrNone )

   540             {

   541             err = AddFillRuleRulesAndParamsL( aFillRule );            

   542             }

   543         if ( err == KErrNone )

   544             {

   545             iRuleGroupID++;

   546             BackUpIdL( ERuleGroupID, iRuleGroupID );

   547             }

   548         }               

   549 

   550     iDatabase.Exec( KCmDbSqlCommit );    

   551         

   552     // in error cases force return value to KErrGeneral

   553     return ( err ? KErrGeneral : KErrNone );  

   554     }

   555 

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

   557 // CCmDmSQLiteConnection::AddFillRuleMediaServersL

   558 // ---------------------------------------------------------------------------

   559 //

   560 TInt CCmDmSQLiteConnection::AddFillRuleMediaServersL( CCmFillRule* aFillRule )

   561     {

   562     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::\

   563     AddFillRuleMediaServersL()"));

   564     

   565     TInt mediaServerCount( aFillRule->MediaServerCount() );

   566     

   567     TInt mediaserverID(0);

   568     TInt err( KErrNone );

   569     for( TInt i = 0; i < mediaServerCount ; i++ )

   570         {

   571         TPtrC8 udn = aFillRule->MediaServerL( i );

   572         aFillRule->MediaServerL( i, mediaserverID );

   573         if( udn.Length() )

   574             {

   575             err = 

   576                 iStatement.Prepare( iDatabase, KSelectMediaServerIDByUDN );

   577             if( !err )

   578                 {

   579                 iStatement.BindBinary( 0, udn );                 

   580                 // Loop all rows in results

   581                 while ( iStatement.Next() == KSqlAtRow )  

   582                     {

   583                     // Get cell contents    

   584                     mediaserverID = iStatement.ColumnInt64( 0 );

   585                     }                

   586                 }

   587             iStatement.Reset();                     

   588             iStatement.Close();                                               

   589             }

   590         if( mediaserverID > 0 )

   591             {

   592             err = iStatement.Prepare( iDatabase, KAddRuleGroupServer );

   593             if( err )

   594                 {

   595                 err = KErrGeneral;

   596                 }

   597             else

   598                 {

   599                 iStatement.BindInt64( 0, 

   600                     iRuleGroupID );    

   601                 iStatement.BindInt64( 1, 

   602                     mediaserverID );

   603                 iStatement.Exec();

   604                 iStatement.Reset();

   605                 iStatement.Close();

   606                 err = KErrNone;                                          

   607                 }             

   608             }                              

   609         }            

   610     

   611     return err;        

   612     }

   613 // ---------------------------------------------------------------------------

   614 // CCmDmSQLiteConnection::AddFillRuleRulesAndParamsL

   615 // ---------------------------------------------------------------------------

   616 //

   617 TInt CCmDmSQLiteConnection::AddFillRuleRulesAndParamsL( 

   618     CCmFillRule* aFillRule )

   619     {

   620     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::\

   621     AddFillRuleRulesAndParamsL()"));

   622     

   623     TInt ruleCount(aFillRule->RuleCount());

   624     TInt err( KErrNone );

   625     TCmMetadataField metadataField;

   626     TPtrC8 dataField;

   627     TInt dataIndex;

   628     TCmOperatorType oper;

   629     TInt parameterCount(0);   

   630     for( TInt j = 0; j < ruleCount; j++)

   631         {

   632         aFillRule->RuleL( j, &metadataField, &oper, &parameterCount );

   633 

   634         err = iStatement.Prepare( iDatabase, KAddRule );

   635         

   636         if( err )

   637             {

   638             TRACE(Print(_L("[DATABASE MANAGER]\t \

   639                 CCmDmSQLiteConnection::AddFilledL() FAILED ")));

   640             err = KErrGeneral;

   641             }

   642         else

   643             {

   644             iStatement.BindInt64( 0, iRuleID );

   645             iStatement.BindInt64( 1, iRuleGroupID );

   646             iStatement.BindInt( 2, metadataField );

   647             iStatement.BindInt( 3, oper );

   648             iStatement.Exec();

   649             iStatement.Reset();        

   650             iStatement.Close(); 

   651             err = KErrNone; 

   652             }

   653         

   654         // Add params of the rule to table        

   655         for( TInt k = 0; k < parameterCount; k++)

   656             {

   657             aFillRule->RuleParamL( j, k, &dataField );

   658             aFillRule->RuleParamL( j, k, dataIndex );

   659             err = iStatement.Prepare( iDatabase, KAddRuleParam );

   660             

   661             if( err )

   662                 {

   663                 TRACE(Print(_L("[DATABASE MANAGER]\t \

   664                     CCmDmSQLiteConnection::AddFilledL() FAILED ")));

   665                 err = KErrGeneral;

   666                 }

   667             else

   668                 {

   669                 iStatement.BindInt64( 0, iRuleParamID );

   670                 iRuleParamID++; 

   671                 iStatement.BindInt64( 1, iRuleID );

   672                 if( dataField.Length() )

   673                     {

   674                     iStatement.BindBinary( 2, dataField );    

   675                     }

   676                 else

   677                     {

   678                     iStatement.BindInt64( 3, dataIndex );

   679                     }

   680                 iStatement.Exec();

   681                 iStatement.Reset();      

   682                 iStatement.Close();

   683                 err = KErrNone;  

   684                 }            

   685             }

   686         iRuleID++;            

   687         }

   688     BackUpIdL( ERuleID, iRuleID );

   689     BackUpIdL( ERuleParamID, iRuleParamID );                    

   690 

   691     return err;

   692     }        

   693 

   694 // ---------------------------------------------------------------------------

   695 // CCmDmSQLiteConnection::AddStoreRuleL

   696 // ---------------------------------------------------------------------------

   697 //

   698 TInt CCmDmSQLiteConnection::AddStoreRuleL( CCmStoreRule* aStoreRule )

   699     {

   700     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoreRuleL()"));

   701     

   702     TInt err = iStatement.Prepare( iDatabase, KAddStoreRule );

   703     

   704     if ( err == KErrNone )

   705         {

   706         iStatement.BindInt64( 0, iStoreRuleID );

   707         iStatement.BindBinary( 1, aStoreRule->Name() );

   708         iStatement.BindInt( 2, aStoreRule->Selected() );

   709         iStatement.BindInt( 3, aStoreRule->Status() );

   710         iStatement.Exec();

   711         iStatement.Reset();

   712         iStatement.Close();

   713     

   714         err = AddStoreRuleParamsL( aStoreRule );

   715 

   716         if ( err == KErrNone )

   717             {

   718             err = AddStoreRuleMediaServersL( aStoreRule );

   719             }

   720         if ( err == KErrNone )

   721             {

   722             iStoreRuleID++;

   723             BackUpIdL( EStoreRuleID, iStoreRuleID );

   724             }

   725         }

   726   

   727     // in error cases force return value to KErrGeneral

   728     return ( err ? KErrGeneral : KErrNone );    

   729     }

   730 

   731 // ---------------------------------------------------------------------------

   732 // CCmDmSQLiteConnection::AddStoreRuleParamsL

   733 // ---------------------------------------------------------------------------

   734 //

   735 TInt CCmDmSQLiteConnection::AddStoreRuleParamsL( CCmStoreRule* aStoreRule )

   736     {

   737     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddStoreRuleParamsL()"));

   738     

   739     TInt err( KErrNone );

   740     TCmMediaType mediaType; 

   741     // Ensin tavara fillrule group tauluun

   742     for(TInt i = 0; i < aStoreRule->DefCount(); i++ )

   743         {

   744         aStoreRule->StoreRule(i, &mediaType);

   745         err = iStatement.Prepare( iDatabase, KAddStoreRuleParams );    

   746         if( err )

   747             {

   748             TRACE(Print(_L("[DATABASE MANAGER]\t \

   749                 CCmDmSQLiteConnection::AddStoreRuleParamsL() FAILED ")));

   750             err = KErrGeneral;

   751             }

   752         else

   753             {        

   754             iStatement.BindInt64( 0, iStoreRuleID );

   755             iStatement.BindInt64( 1, iStoreRuleParamID );

   756             iStatement.BindInt( 2, (TInt)mediaType );

   757             iStatement.Exec();

   758             iStatement.Reset();

   759             iStatement.Close();            

   760             }

   761         iStoreRuleParamID++;            

   762         }

   763     BackUpIdL( EStoreRuleParamID, iStoreRuleParamID );        

   764 

   765     return err;        

   766     }

   767 

   768 // ---------------------------------------------------------------------------

   769 // CCmDmSQLiteConnection::AddStoreRuleMediaServersL

   770 // ---------------------------------------------------------------------------

   771 //

   772 TInt CCmDmSQLiteConnection::AddStoreRuleMediaServersL( 

   773     CCmStoreRule* aStoreRule )

   774     {

   775     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::\

   776     AddStoreRuleMediaServersL()"));

   777     

   778     TInt err( KErrNone );         

   779     TInt mediaServerCount( aStoreRule->MediaServerCount() );

   780     TRACE(Print(_L("[DATABASE MANAGER]\t \

   781         mediaServerCount = %d "), mediaServerCount));    

   782     if( mediaServerCount > KErrNone )

   783         {

   784         for( TInt i = 0; i < mediaServerCount ; i++ )

   785             {

   786             err = iStatement.Prepare( iDatabase, 

   787                 KSelectMediaServerIDByUDN );        

   788 

   789             TUint64 mediaserverID(0);            

   790             TPtrC8 udn = aStoreRule->MediaServerL( i );

   791             iStatement.BindBinary( 0, udn );

   792             if( err )

   793                 {

   794                 err = KErrGeneral;

   795                 }

   796             else

   797                 {        

   798                 // Loop all rows in results

   799                 if ( iStatement.Next() == KSqlAtRow )

   800                     {

   801                     // Get cell contents    

   802                     mediaserverID = iStatement.ColumnInt64( 0 );

   803                     iStatement.Reset();

   804                     iStatement.Close();                         

   805                     err = iStatement.Prepare( iDatabase, 

   806                         KAddStoreRuleServers );

   807                     if( err )

   808                         {

   809                         err = KErrGeneral;

   810                         }

   811                     else

   812                         {

   813                         iStatement.BindInt64( 0, iStoreRuleID );    

   814                         iStatement.BindInt64( 1, mediaserverID );

   815                         iStatement.Exec();

   816                         iStatement.Reset();

   817                         iStatement.Close();

   818                         err = KErrNone;

   819                         }

   820                                         

   821                     }   

   822                 }               

   823             }        

   824         }               

   825     

   826     return err;

   827     }

   828     

   829 // ---------------------------------------------------------------------------

   830 // CCmDmSQLiteConnection::AddMediaServerL

   831 // ---------------------------------------------------------------------------

   832 //

   833 TInt CCmDmSQLiteConnection::AddMediaServerL( 

   834     CCmMediaServerFull* aMediaServer )

   835     {

   836     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddMediaServerL()"));    

   837     

   838     TInt err = iStatement.Prepare( iDatabase, KAddMediaServer );

   839     if( err )

   840         {

   841         TRACE(Print(_L("[DATABASE MANAGER]\t \

   842             CCmDmSQLiteConnection::AddMediaServerL() FAILED ")));

   843         err = KErrGeneral;

   844         }

   845     else

   846         {

   847         iStatement.BindInt64( 0, iMediaServerID ); 

   848         iStatement.BindBinary( 1, aMediaServer->MediaServer() );

   849         iStatement.BindBinary( 2, aMediaServer->MediaServerName() );

   850         iStatement.BindInt( 3, aMediaServer->SystemUpdateID() );

   851         iStatement.BindInt64( 4, aMediaServer->VisibleDate().Int64() );

   852         iStatement.BindInt( 5, KErrNone );

   853         iStatement.BindInt( 6, KErrNone );

   854         iStatement.BindInt( 7, KErrNone );

   855         iStatement.BindInt( 8, KErrNone );

   856         iStatement.BindInt( 9, KErrNone );

   857         iStatement.BindInt( 10, (TInt)aMediaServer->CopyCapability() );

   858         iStatement.BindInt( 11, aMediaServer->FillUsage() );

   859         iStatement.BindInt( 12, aMediaServer->StoreUsage() );

   860         iStatement.Exec();

   861         iStatement.Reset();

   862         iStatement.Close();

   863         err = KErrNone;  

   864         }

   865     iMediaServerID++;

   866     BackUpIdL( EMediaServerID, iMediaServerID );        

   867    

   868     return err;

   869     }

   870 

   871 // ---------------------------------------------------------------------------

   872 // CCmDmSQLiteConnection::AddHashValue

   873 // ---------------------------------------------------------------------------

   874 //

   875 TInt CCmDmSQLiteConnection::AddHashValue( TInt64 aMediaServerId, 

   876                                           CCmSearchResponseHash* aHashValue )

   877     

   878     {

   879     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::AddHashValue()"));

   880         

   881     TInt err = iStatement.Prepare( iDatabase, KAddHashValue );

   882     if( err )

   883         {

   884         TRACE(Print(_L("[DATABASE MANAGER]\t \

   885             CCmDmSQLiteConnection::AddHashValue() FAILED ")));

   886         err = KErrGeneral;

   887         }

   888     else

   889         {

   890         iStatement.BindInt64( 0, aMediaServerId ); 

   891         iStatement.BindInt( 1, aHashValue->StartIndex() );

   892         iStatement.BindInt( 2, aHashValue->ItemCount()  );

   893         iStatement.BindBinary( 3, aHashValue->Hash() );

   894         iStatement.Exec();

   895         iStatement.Reset();

   896         iStatement.Close();

   897         err = KErrNone;  

   898         }

   899       

   900     return err;

   901     }

   902     

   903 // ---------------------------------------------------------------------------

   904 // CCmDmSQLiteConnection::SetMediaServersL

   905 // ---------------------------------------------------------------------------

   906 //

   907 TInt CCmDmSQLiteConnection::SetMediaServersL( 

   908     RPointerArray<CCmMediaServerFull>& aServers )  

   909     {

   910     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetMediaServersL()"));    

   911     TInt err( KErrNone );

   912     

   913     TInt sqlRet( iDatabase.Exec( KInitIsActiveFlags ) );

   914 

   915     if ( sqlRet >= KErrNone )

   916         {

   917         TRACE(Print(_L("[DATABASE MANAGER]\t \

   918             %d rows have been changed/inserted/deleted"), sqlRet ));

   919 

   920         TInt id( KErrNone );

   921         // Add new servers into 

   922         HBufC8* uuid = NULL;

   923         for( TInt j = 0; j < aServers.Count(); j++ )

   924             {

   925             uuid = aServers[j]->MediaServer().AllocLC();

   926             PrepareQueryCmdL(EMediaServerIdQuery);

   927             id = QueryMediaServerId( *uuid );

   928             if( id == KErrNotFound )

   929                 {

   930                 AddMediaServerL( aServers[j] );

   931                 }

   932             CleanupStack::PopAndDestroy( uuid );

   933             uuid = NULL;    

   934             }

   935         

   936         for( TInt i = 0; i < aServers.Count() ; i++ )

   937             {

   938             err = iStatement.Prepare( iDatabase, KUpdateMsIsActive );

   939         

   940             if( err )

   941                 {

   942                 TRACE(Print(_L("[DATABASE MANAGER]\t \

   943                 CCmDmSQLiteConnection::SetMediaServersL() FAILED ")));

   944                 err = KErrGeneral;

   945                 }

   946             else

   947                 {

   948                 iStatement.BindInt( 0, aServers[i]->IsActive() );

   949                 iStatement.BindInt( 1, aServers[i]->SystemUpdateID() );

   950                 //update the server name

   951                 iStatement.BindBinary( 2, aServers[i]->MediaServerName() );

   952                 iStatement.BindInt( 3, aServers[i]->FillUsage() );

   953                 iStatement.BindInt( 4, aServers[i]->StoreUsage() );

   954                 iStatement.BindBinary( 5, aServers[i]->MediaServer() );

   955                 iStatement.Exec();                

   956                 }

   957             iStatement.Reset(); 

   958             iStatement.Close();            

   959             }     

   960         

   961         if ( err == KErrNone )

   962             {

   963             err = DeleteInActiveRuleServers();

   964             }

   965     	        

   966         if ( err == KErrNone )

   967             {

   968             err = DeleteInActiveFiles();            

   969             }        

   970         }

   971 

   972     return err;

   973     }

   974 

   975 // ---------------------------------------------------------------------------

   976 // CCmDmSQLiteConnection::SetSyncTime

   977 // ---------------------------------------------------------------------------

   978 //

   979 TInt CCmDmSQLiteConnection::SetSyncTime()

   980     {

   981     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetSyncTime()"));    

   982     

   983     TInt err( iDatabase.Exec( KRemoveSyncTime ) );   

   984     

   985     if ( err == KErrNone )

   986         {

   987         err = iStatement.Prepare( iDatabase, KSetSyncTime );

   988         if ( err == KErrNone )

   989             {

   990             TTime time;

   991             time.HomeTime();

   992             iStatement.BindInt64( 0, time.Int64() );

   993             iStatement.Exec();               

   994             }

   995         iStatement.Reset(); 

   996         iStatement.Close();         

   997         }

   998     // in error cases force return value to KErrGeneral

   999     return ( err ? KErrGeneral : KErrNone ); 

  1000     }

  1001 

  1002 // ---------------------------------------------------------------------------

  1003 // CCmDmSQLiteConnection::GetSyncTime

  1004 // ---------------------------------------------------------------------------

  1005 //

  1006 TInt CCmDmSQLiteConnection::GetSyncTime( TTime& aTime )

  1007     {

  1008     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::GetSyncTime()"));    

  1009     

  1010     TInt err( iStatement.Prepare( iDatabase, KGetSyncTime ) );

  1011     aTime = KErrNone;

  1012     if( err )

  1013         {

  1014         err = KErrGeneral;  

  1015         }

  1016     else

  1017         {

  1018         err = iStatement.Next(); 

  1019         if ( err == KSqlAtRow )  

  1020             { 

  1021             aTime = iStatement.ColumnInt64( 0 );

  1022             err = KErrNone;                

  1023             }

  1024         }

  1025     iStatement.Reset(); 

  1026     iStatement.Close();     

  1027     return err;

  1028     }

  1029 

  1030 // ---------------------------------------------------------------------------

  1031 // CCmDmSQLiteConnection::SetProgressInfo

  1032 // ---------------------------------------------------------------------------

  1033 //

  1034 TInt CCmDmSQLiteConnection::SetProgressInfo( TInt aTransferred, 

  1035     TInt aTotalCount)

  1036     {

  1037     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetProgressInfo()"));    

  1038     

  1039     TInt err( iDatabase.Exec( KRemoveProgressInfo ) );

  1040     if ( err == KErrNone )

  1041         {

  1042         err = iStatement.Prepare( iDatabase, KSetProgressInfo );

  1043         if( err )

  1044             {

  1045             err = KErrGeneral;

  1046             }

  1047         else

  1048             {

  1049             iStatement.BindInt( 0, aTransferred );

  1050             iStatement.BindInt( 1, aTotalCount );

  1051             iStatement.Exec();        

  1052             }

  1053         iStatement.Reset(); 

  1054         iStatement.Close();                 

  1055         }

  1056         

  1057     return err;    

  1058     }

  1059 

  1060 // ---------------------------------------------------------------------------

  1061 // CCmDmSQLiteConnection::GetProgressInfo

  1062 // ---------------------------------------------------------------------------

  1063 //

  1064 TInt CCmDmSQLiteConnection::GetProgressInfo( TInt& aTransferred, 

  1065     TInt& aTotalCount )

  1066     {

  1067     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::GetProgressInfo()"));    

  1068     

  1069     TInt err( iStatement.Prepare( iDatabase, KGetProgressInfo ) );

  1070     if( err )

  1071         {

  1072         err = KErrGeneral;  

  1073         }

  1074     else

  1075         {

  1076         err = iStatement.Next();

  1077         if ( err == KSqlAtRow )  

  1078             {

  1079             aTransferred = iStatement.ColumnInt( 0 );

  1080             aTotalCount = iStatement.ColumnInt( 1 );

  1081             err = KErrNone;                         

  1082             }

  1083         }

  1084     iStatement.Reset(); 

  1085     iStatement.Close();     

  1086     return err;    

  1087     }

  1088 

  1089 // ---------------------------------------------------------------------------

  1090 // CCmDmSQLiteConnection::SetDrivesL

  1091 // ---------------------------------------------------------------------------

  1092 //

  1093 void CCmDmSQLiteConnection::SetDrivesL( RPointerArray<CCmDriveInfo>& aDrives )

  1094     {

  1095     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::SetDrivesL()"));    

  1096     

  1097     TInt err( iDatabase.Exec( KRemoveDrivesInfo ) );

  1098     

  1099     if ( err == KErrNone)

  1100         {

  1101         iDatabase.Exec( KCmDbBeginTransaction );   

  1102         for( TInt i = 0; i < aDrives.Count(); i++ )

  1103             {

  1104             err = iStatement.Prepare( iDatabase, KSetDrivesInfo );

  1105             User::LeaveIfError( err ); 

  1106             iStatement.BindInt( 0, aDrives[i]->DriveNumber() );

  1107             iStatement.BindInt( 1, aDrives[i]->DriveType() );

  1108             iStatement.BindText( 2, aDrives[i]->DriveName() );

  1109             iStatement.BindInt64( 3, aDrives[i]->DriveSize() );

  1110             iStatement.BindInt64( 4, aDrives[i]->DriveQuota() );

  1111             iStatement.BindInt64( 5, aDrives[i]->UsedDriveQuota() );

  1112             iStatement.BindInt64( 6, aDrives[i]->DriveId() );

  1113             iStatement.BindInt( 7, aDrives[i]->Status() );

  1114             iStatement.Exec();

  1115             iStatement.Reset();

  1116             iStatement.Close();

  1117             }        

  1118         }

  1119     iDatabase.Exec( KCmDbSqlCommit );              

  1120     }

  1121                 

  1122 // ---------------------------------------------------------------------------

  1123 // CCmDmSQLiteConnection::PrepareQueryCmdL

  1124 // ---------------------------------------------------------------------------

  1125 //

  1126 void CCmDmSQLiteConnection::PrepareQueryCmdL( TCMQueryCmdType aType )

  1127     {

  1128     LOG( _L( "[DB MNGR]\t CCmDmSQLiteConnection::PrepareQueryCmdL()"));

  1129     

  1130     TInt err( KErrNone );                  

  1131     switch( aType )

  1132         {

  1133         case EFillRuleQuery:

  1134             {