1 /*

     2 * Copyright (c) 2009 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:  Fill rule and filled data processing

    15 *  Version     : %version: ou1s60rt#18 % << Don't touch!

    16 *

    17 */

    18 

    19 

    20 

    21 #include <e32property.h>

    22 #include "upnpdlnautility.h"

    23 #include "cmsqlmainfactory.h"

    24 #include "mcmsqlmain.h"

    25 #include "cmdmmain.h"

    26 #include "cmfillrule.h"

    27 #include "cmfillrulecontainer.h"

    28 #include "cmsqlpropertyitem.h"

    29 #include "cmmediaserverfull.h"

    30 #include "cmfilllistitem.h"

    31 #include "cmfmmain.h"

    32 #include "cmfmao.h"

    33 #include "cmfmfillrulefilleddatamngr.h"

    34 #include "msdebug.h"

    35 

    36 // Constants

    37 const TInt KCmFmIniDownloadDataAmount = 300; // 300 kBs

    38 const TInt KCmFmIniDownloadTime = 1; // One second

    39 

    40 

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

    42 // CCmFmFillRuleFilledDataMngr::NewL

    43 // ---------------------------------------------------------------------------

    44 //

    45 CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewL(

    46     MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

    47     RPointerArray<CCmFillListItem>& aItems )

    48     {

    49     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() start"));    

    50     CCmFmFillRuleFilledDataMngr* self = CCmFmFillRuleFilledDataMngr::NewLC(

    51         aObserver, aDBMngr, aItems );

    52     CleanupStack::Pop( self );

    53     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() end")); 

    54     return self;

    55     }

    56 

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

    58 // CCmFmFillRuleFilledDataMngr::NewLC

    59 // ---------------------------------------------------------------------------

    60 //    

    61 CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewLC(

    62     MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

    63     RPointerArray<CCmFillListItem>& aItems )

    64     {

    65     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() start"));     

    66     CCmFmFillRuleFilledDataMngr* self = 

    67         new ( ELeave ) CCmFmFillRuleFilledDataMngr( aObserver, aDBMngr, 

    68                                                     aItems );

    69     CleanupStack::PushL( self );

    70     self->ConstructL();

    71     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() end"));     

    72     return self;  

    73     }    

    74 

    75 // ---------------------------------------------------------------------------

    76 // CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr

    77 // ---------------------------------------------------------------------------

    78 //

    79 CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr()

    80     {

    81     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

    82         ~CCmFmFillRuleFilledDataMngr() start"));

    83     Cancel();

    84     

    85     if ( iWrapper )

    86         {

    87         iWrapper->Close();    

    88         }    

    89     

    90     if ( iAo )

    91         {

    92         delete iAo;      

    93         }

    94     

    95     iObserver = NULL;

    96     iDBManager = NULL;

    97     

    98     if ( iContainer )

    99         {

   100         delete iContainer;    

   101         }

   102     

   103     iRuleArray.Reset();

   104     iRuleArray.Close();

   105     

   106     iUpdateItems.Reset();

   107     iUpdateItems.Close();        

   108     

   109     iPropertys.ResetAndDestroy();

   110     

   111     iFileIds.Close();

   112     iMetadataServersToBeDeleted.Close();

   113     iOldIds.Close();

   114     iFs.Close();

   115     iFilteredProfiles.Reset();

   116     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   117         ~CCmFmFillRuleFilledDataMngr() end"));

   118     }

   119 

   120 // ---------------------------------------------------------------------------

   121 // CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr

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

   123 //            

   124 CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr( 

   125     MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr,

   126     RPointerArray<CCmFillListItem>& aItems )

   127     :CActive( EPriorityStandard ), iObserver( aObserver ), 

   128     iDBManager( aDBMngr ), iItems(aItems)

   129     {

   130     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   131     CCmFmFillRuleFilledDataMngr()"));    

   132     

   133     CActiveScheduler::Add( this );

   134     iTransferInfo.iService = ECmServiceTransferInfoFill;

   135     }

   136 

   137 // ---------------------------------------------------------------------------

   138 // CCmFmFillRuleFilledDataMngr::ConstructL

   139 // ---------------------------------------------------------------------------

   140 //  

   141 void CCmFmFillRuleFilledDataMngr::ConstructL()

   142     {

   143     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::ConstructL()"));   

   144     User::LeaveIfError( iFs.Connect() );                           

   145     }

   146 

   147 // ---------------------------------------------------------------------------

   148 // CCmFmFillRuleFilledDataMngr::OperationCompletedL

   149 // ---------------------------------------------------------------------------

   150 // 

   151 void CCmFmFillRuleFilledDataMngr::OperationCompletedL( TInt aStatus )

   152     {

   153     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   154     OperationCompletedL()"));

   155     

   156     iQueryFinished.HomeTime();

   157     TTimeIntervalMicroSeconds usecsFrom = 

   158         iQueryFinished.MicroSecondsFrom( iQueryStart );

   159     TRACE(Print(_L("[FILL MNGR]\t Query \

   160         took = %ld mseconds"), ( usecsFrom.Int64() / 1000 ) ));    

   161     

   162     if( KErrNone == aStatus )

   163         {

   164         switch( iProcessingState )

   165             {

   166             case ECmFmLoadingPropertys:

   167                 {

   168                 // Loading propertys ready

   169                 CompleteRequest( EColumnDataReady );

   170                 break;

   171                 }

   172             case ECmFmLoadingMetadata:

   173                 {

   174                 // Loading file metadata ready ( for one fill list )

   175                 iNewItemCount = iItems.Count() - iNewItemCount;              

   176                 CompleteRequest( EQueryCompleted );

   177                 break;

   178                 }

   179             case ECmFmDeletingMetadata:

   180                 {

   181                 // Metadata deleted from defined media servers

   182                 TRAPD( err, DeleteHashCodesL() );

   183                 iMetadataServersToBeDeleted.Reset();

   184                 iMetadataServersToBeDeleted.Close();

   185                 iWrapper->DeleteUnusedPropertys( );

   186                 if( !err )

   187                     {

   188                     CompleteRequest( EMetadataDeleted );

   189                     }

   190                 else

   191                     {

   192                     TRACE(Print(_L("[FILL MNGR]\t \

   193                         OperationCompletedL err %d "), err ));                    

   194                     }                                    

   195                 break;

   196                 }

   197             case ECmFmLoadingProfileIds:

   198                 {

   199                 DefineAndSetDlnaProfileIdFiltersL();

   200                 PreprocessListsL();

   201                 break;

   202                 }

   203             default:

   204                 {

   205                 LOG(_L("[FILL MNGR]\t OperationCompletedL processing \

   206                 state not found"));

   207                 break;

   208                 }    

   209             }         

   210         }

   211     else

   212         {        

   213         TRACE(Print(_L("[FILL MNGR]\t OperationCompletedL aStatus = %d"), 

   214             aStatus ));        

   215         }         

   216     }

   217 

   218 // ---------------------------------------------------------------------------

   219 // CCmFmFillRuleFilledDataMngr::LoadProfileIdsL

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

   221 //

   222 void CCmFmFillRuleFilledDataMngr::LoadProfileIdsL()

   223     {

   224     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadProfileIdsL()"));

   225     // Loads all dlna profile ids from database. Profile ids are used

   226     // to filter out unsupported media types

   227     iPropertys.ResetAndDestroy();

   228     iProcessingState = ECmFmLoadingProfileIds;

   229     CreateWrapperL();

   230     StartObserverL();

   231     iWrapper->GetPropertyValuesL( iPropertys, iAo->iStatus, 

   232         ECmProfileId, ECmAll );

   233     iQueryStart.HomeTime();

   234     iAo->RunL();    

   235     }

   236         

   237 // ---------------------------------------------------------------------------

   238 // CCmFmFillRuleFilledDataMngr::PreprocessListsL

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

   240 // 

   241 void CCmFmFillRuleFilledDataMngr::PreprocessListsL()

   242     {

   243     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreprocessListsL()"));

   244     

   245 #ifdef _DEBUG

   246     TInt alloc;

   247     TInt cells = User::Heap().AllocSize( alloc );

   248     TInt size = User::Heap().Size();

   249     TRACE(Print(_L("[FILL MNGR]\t preprocess heap allocsize %d, \

   250     size %d, cells %d"), alloc, size, cells ));

   251 #endif

   252     iProcessingState = ECmFmIdle;  

   253     ResetData();

   254     // Creates sqlite wrapper and starts preprocessing of all fill lists

   255     TRAP_IGNORE( CreateWrapperL() );

   256     iTransferInfo.iTotalItems = KErrNone;

   257     iTransferInfo.iProcessedItems = KErrNone;        

   258     CompleteRequest( EPreProcessingStarted );   

   259     }

   260 

   261 // ---------------------------------------------------------------------------

   262 // CCmFmFillRuleFilledDataMngr::PreProcessListL

   263 // ---------------------------------------------------------------------------

   264 // 

   265 void CCmFmFillRuleFilledDataMngr::PreProcessListL( 

   266     const TDesC8& aFillListName )

   267     {

   268     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreProcessListL()"));

   269     

   270     iProcessingState = ECmFmIdle;

   271     // Creates sqlite wrapper and starts preprocessing of 

   272     // one defined fill list 

   273     CreateWrapperL();

   274     ResetData();

   275     iContainer = CCmFillRuleContainer::NewL();     

   276     LoadRuleL( aFillListName );

   277     LoadAllFillItemsL();    

   278     CompleteRequest( ERandomizingStarted );

   279     }

   280 

   281 // ---------------------------------------------------------------------------

   282 // CCmFmFillRuleFilledDataMngr::GetColItemsL

   283 // ---------------------------------------------------------------------------

   284 //

   285 void CCmFmFillRuleFilledDataMngr::GetColItemsL( TCmMetadataField aType, 

   286     TCmMediaType aMedia, CCmSqlPropertyContainer& aPropertys )

   287     {

   288     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetColItemsL()"));

   289     

   290     iPropertyContainer = NULL;

   291     iPropertyContainer = &aPropertys;

   292     iPropertys.ResetAndDestroy(); 

   293     iProcessingState = ECmFmLoadingPropertys;

   294     CreateWrapperL();

   295     StartObserverL();

   296     // starts loading defined propertys from database

   297     iWrapper->GetPropertyValuesL(iPropertys, iAo->iStatus, aType, aMedia );

   298     iQueryStart.HomeTime();

   299     iAo->RunL();

   300     }

   301 

   302 // ---------------------------------------------------------------------------

   303 // CCmFmFillRuleFilledDataMngr::GetMetadataItemsL

   304 // ---------------------------------------------------------------------------

   305 //

   306 void CCmFmFillRuleFilledDataMngr::GetMetadataItemsL(

   307                                     CCmSqlPropertyCollector& aPropertys )

   308     {

   309     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   310     GetMetadataItemsL()"));

   311     

   312     iPropertyCollector = NULL;

   313     iPropertyCollector = &aPropertys;    

   314     iProcessingState = ECmFmLoadingPropertys;

   315     CreateWrapperL();

   316     StartObserverL();

   317     // starts loading property values. Selected artists, albums, genres and 

   318     // tracks are used as a filtering parameter ( e.g. if some artist is 

   319     // selected, only albums for that defined artist are loaded.

   320     iWrapper->GetFilteredPropertyValuesL( *iPropertyCollector, iAo->iStatus );

   321     iQueryStart.HomeTime();

   322     iAo->RunL();

   323     }

   324     

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

   326 // CCmFmFillRuleFilledDataMngr::UpdatePriorities

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

   328 //    

   329 void CCmFmFillRuleFilledDataMngr::UpdatePriorities()

   330     {

   331     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::UpdatePriorities()"));

   332     

   333     CompleteRequest( EUpdatePriorities );

   334     }

   335 

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

   337 // CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL

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

   339 //

   340 void CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL()

   341     {

   342     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   343     DoUpdatePrioritiesL()"));

   344     

   345     // Updating first list item priorities    

   346 #ifdef _DEBUG

   347     TInt alloc;

   348     TInt cells = User::Heap().AllocSize( alloc );

   349     TInt size = User::Heap().Size();

   350     TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL start heap \

   351     allocsize %d, size %d, cells %d"), alloc, size, cells ));    

   352 #endif    

   353     

   354     CCmFillRuleContainer* container = LoadAllFillRulesL();

   355     CleanupStack::PushL( container );

   356     TInt err( UpdateListItemPriorities( container ) );

   357     TRACE(Print(_L("[FILL MNGR]\t UpdateListItemPriorities err = %d"), 

   358     err ));     

   359     CleanupStack::PopAndDestroy(container);

   360     CalculateAvgTransferTimeL();

   361     SendAvgTransferTime();

   362 

   363 #ifdef _DEBUG    

   364     cells = User::Heap().AllocSize( alloc );

   365     size = User::Heap().Size();

   366     TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL end heap \

   367     allocsize %d, size %d, cells %d"), alloc, size, cells ));

   368 #endif

   369                   

   370     iObserver->FillRuleProcessingStatus( EDoUpdatePriorities );   

   371     }

   372 

   373 // ---------------------------------------------------------------------------

   374 // CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL

   375 // ---------------------------------------------------------------------------

   376 //

   377 void CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL()

   378     {

   379     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   380     DoUpdateReferenceIdsL()")); 

   381     

   382 #ifdef _DEBUG

   383     TInt alloc;

   384     TInt cells = User::Heap().AllocSize( alloc );

   385     TInt size = User::Heap().Size();

   386     TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL start heap \

   387     allocsize %d, size %d, cells %d"), alloc, size, cells ));    

   388 #endif

   389     

   390     LoadAllFillItemsL();

   391     LOG(_L("[FILL MNGR]\t Items loaded...")); 

   392     

   393     // Processing set referense ids into duplicate items

   394     LOG(_L("[FILL MNGR]\t Processing ref ids..."));

   395 

   396     DoProcessReferenceValuesL();   

   397        

   398     LOG(_L("[FILL MNGR]\t Ref ids processed..."));        

   399     UpdateFillItems();

   400     iItems.ResetAndDestroy();

   401     iItems.Close();

   402 #ifdef _DEBUG    

   403     cells = User::Heap().AllocSize( alloc );

   404     size = User::Heap().Size();

   405     TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL end heap \

   406     allocsize %d, size %d, cells %d"), alloc, size, cells ));

   407 #endif     

   408     }

   409 

   410 // ---------------------------------------------------------------------------

   411 // CCmFmFillRuleFilledDataMngr::DeleteMetadataL

   412 // ---------------------------------------------------------------------------

   413 //

   414 void CCmFmFillRuleFilledDataMngr::DeleteMetadataL()

   415     {

   416     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DeleteMetadataL()")); 

   417     

   418     iMetadataServersToBeDeleted.Reset();

   419     

   420     RPointerArray<CCmMediaServerFull> mediaServers;

   421     CleanupClosePushL( mediaServers );

   422    

   423     iDBManager->GetMediaServersL( mediaServers ); 

   424     

   425     TBool setSystemUpdateIDChange( EFalse );

   426     for( TInt i = 0; i < mediaServers.Count(); i++ )

   427         {

   428         // checks that server is either inactive or deleted

   429         if( mediaServers[i]->DbId() != 0 && 

   430             !( mediaServers[i]->FillUsage() ) )

   431             {

   432             iMetadataServersToBeDeleted.AppendL( mediaServers[i]->DbId() );

   433             TRACE(Print(_L("[FILL MNGR]\t DbId = %ld"), 

   434                 mediaServers[i]->DbId() ));            

   435                 

   436             mediaServers[i]->SetSystemUpdateID( KErrNotFound );

   437                 

   438 			setSystemUpdateIDChange = ETrue;

   439             }

   440         }

   441 

   442 	if ( setSystemUpdateIDChange )

   443 		{

   444 		iDBManager->SetMediaServersL( mediaServers ); 	

   445 		}

   446 

   447     mediaServers.ResetAndDestroy();

   448     CleanupStack::PopAndDestroy( &mediaServers );

   449     

   450     iProcessingState = ECmFmDeletingMetadata;

   451     CreateWrapperL();

   452     StartObserverL();

   453     iWrapper->AsyncMetadataDelete( iMetadataServersToBeDeleted, 

   454         iAo->iStatus );

   455     iQueryStart.HomeTime();

   456     iAo->RunL();        

   457     }

   458         

   459 // ---------------------------------------------------------------------------

   460 // CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota

   461 // ---------------------------------------------------------------------------

   462 // 

   463 void CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota( TInt64 aQuota )

   464     {

   465     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   466     SetMemoryCardQuota()")); 

   467     

   468     if( iWrapper )

   469         {

   470         iWrapper->SetQuota( aQuota );

   471         }

   472     }

   473     

   474 // ---------------------------------------------------------------------------

   475 // CCmFmFillRuleFilledDataMngr::CancelOperation

   476 // ---------------------------------------------------------------------------

   477 //    

   478 void CCmFmFillRuleFilledDataMngr::CancelOperation()

   479     {

   480     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CancelOperation()"));

   481     

   482     Cancel();    

   483     if( iWrapper )

   484         {

   485         iWrapper->CancelAsyncOperation();

   486         }

   487     DeleteWrapper(); 

   488     if( iAo )

   489         {

   490         if( iAo->IsActive() )

   491             {

   492             iAo->Cancel();

   493             } 

   494         delete iAo;

   495         iAo = NULL;      

   496         }

   497     LOG(_L("[FILL MNGR]\t iAo canceled..."));          

   498     iObserver->FillRuleProcessingStatus(EProcessingCanceled);           

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData

   503 // ---------------------------------------------------------------------------

   504 //

   505 void CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData( 

   506     TInt64 aInterval, TInt64 aDataAmount, 

   507     TUint8 aServerId )

   508     {

   509     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   510     UpdateTransferHistoryData()")); 

   511     

   512     iDBManager->UpdateDownloadHistory( (TUint)aServerId, aDataAmount,

   513         aInterval );

   514     }

   515 

   516 // ---------------------------------------------------------------------------

   517 // CCmFmFillRuleFilledDataMngr::GetFillItemsL

   518 // ---------------------------------------------------------------------------

   519 //

   520 void CCmFmFillRuleFilledDataMngr::GetFillItemsL()

   521     {

   522     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetFillItemsL()")); 

   523     

   524     iItems.ResetAndDestroy();

   525     iItems.Close();

   526     iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery);

   527     iDBManager->GetAllFillFilesL( iItems, 

   528         ECmToBeShrinked|ECmToBeFilled|ECmFilled|ECmLocalCopy );

   529     }

   530 

   531 // ---------------------------------------------------------------------------

   532 // CCmFmFillRuleFilledDataMngr::GetToBeDeletedL

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

   534 //

   535 void CCmFmFillRuleFilledDataMngr::GetToBeDeletedL(

   536     RPointerArray<CCmFillListItem>& aArray )

   537     {

   538     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetToBeDeletedL()")); 

   539     

   540     iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery);

   541     iDBManager->GetAllFillFilesL( aArray, ECmToBeRemoved );   

   542     }

   543 

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

   545 // CCmFmFillRuleFilledDataMngr::UpdateFillItems

   546 // ---------------------------------------------------------------------------

   547 //    

   548 void CCmFmFillRuleFilledDataMngr::UpdateFillItems( TBool aCancel )

   549     {

   550     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::UpdateFillItems()")); 

   551     

   552     iDBManager->DeleteFillFiles();

   553     if( aCancel && iUpdateItems.Count() )

   554         {

   555         iDBManager->SetFillFiles( iUpdateItems );

   556         }

   557     else

   558         {

   559         iDBManager->SetFillFiles( iItems );

   560         }

   561     iUpdateItems.Reset();

   562     iUpdateItems.Close();

   563 

   564     iItems.ResetAndDestroy();

   565     iItems.Close();

   566 

   567     TRAP_IGNORE( CalculateAvgTransferTimeL() );

   568     SendAvgTransferTime();    

   569     }

   570 

   571 // ---------------------------------------------------------------------------

   572 // CCmFmFillRuleFilledDataMngr::UpdateToBeDeleted

   573 // ---------------------------------------------------------------------------

   574 //    

   575 void CCmFmFillRuleFilledDataMngr::UpdateToBeDeleted( 

   576     RPointerArray<CCmFillListItem>& aArray )

   577     {

   578     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   579     UpdateToBeDeleted()")); 

   580     

   581     // This function is needed when fill is processed only partially

   582     // Some of the to be deleted files are still on device

   583     iDBManager->SetFillFiles( aArray );

   584     aArray.ResetAndDestroy();

   585     aArray.Close();

   586     }

   587 

   588 // ---------------------------------------------------------------------------

   589 // CCmFmFillRuleFilledDataMngr::GetUuidL

   590 // ---------------------------------------------------------------------------

   591 //

   592 TInt CCmFmFillRuleFilledDataMngr::GetUuidL( HBufC8*& aUuid, TUint8 aId )

   593     {

   594     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetUuidL()")); 

   595     

   596     iDBManager->PrepareQueryCmdL( EMediaServerUDNQuery );

   597     return iDBManager->QueryMediaServerUdn(aUuid, aId);      

   598     }

   599 

   600 // ---------------------------------------------------------------------------

   601 // CCmFmFillRuleFilledDataMngr::ResetData

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

   603 //  

   604 void CCmFmFillRuleFilledDataMngr::ResetData()

   605     {

   606     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::ResetData()")); 

   607     

   608     iNewItemCount = KErrNone;

   609     

   610     iRuleArray.Reset();

   611     iRuleArray.Close();

   612     

   613     iUpdateItems.Reset();

   614     iUpdateItems.Close();    

   615 

   616     iItems.ResetAndDestroy();

   617     iItems.Close();

   618     

   619     iFileIds.Close();

   620     iOldIds.Close(); 

   621     

   622     if( iContainer )

   623         {

   624         delete iContainer;

   625         iContainer = NULL;

   626         }              

   627     }

   628 

   629 // ---------------------------------------------------------------------------

   630 // CCmFmFillRuleFilledDataMngr::CalculateAvgTransferTimeL

   631 // ---------------------------------------------------------------------------

   632 //

   633 void CCmFmFillRuleFilledDataMngr::CalculateAvgTransferTimeL()

   634     {

   635     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   636     CalculateAvgTransferTimeL()")); 

   637     

   638     TInt64 ud(KErrNone);

   639     TInt64 dd(KErrNone);

   640     TInt64 ut(KErrNone);

   641     TInt64 dt(KErrNone);

   642     TInt64 size( KErrNone );

   643     TInt64 shrinkTime(KErrNone);

   644     TInt64 transferTime(KErrNone);

   645     TInt ret( KErrNone );   

   646     RPointerArray<CCmMediaServerFull> servers;

   647     CleanupClosePushL( servers );

   648     

   649     iDBManager->PrepareQueryCmdL( EMediaServersAllQuery );

   650     while( !ret )

   651         {

   652         CCmMediaServerFull* server = CCmMediaServerFull::NewLC();

   653         ret = iDBManager->QueryAllMediaServersL( server );

   654         if( !ret )

   655             {

   656             servers.AppendL( server );

   657             CleanupStack::Pop( server );

   658             }

   659         else

   660             {

   661             CleanupStack::PopAndDestroy( server );

   662             }   

   663         }

   664     TRACE( Print( _L("[FILL MNGR]\t servers.Count() = %d"),

   665         servers.Count() ));             

   666     for( TInt i = 0; i < servers.Count(); i++ )

   667         {

   668         iDBManager->PrepareQueryCmdL(ETransferHistoryQuery);

   669         TPtrC8 ser( servers[i]->MediaServer() );

   670         if( &ser )

   671             {

   672             iDBManager->QueryTransferHistory( 

   673                 ser, dd, ud, dt, ut );

   674             size = iDBManager->KBytesToBeFilled( 

   675                 GetMediaServerIdL(ser), 

   676                 ECmToBeShrinked|ECmToBeFilled );

   677             TRACE( Print( _L("[FILL MNGR]\t data amount \

   678                 to be filled = %ld"), size ));

   679                 

   680             TRACE( Print( _L("[FILL MNGR]\t transferred data = %ld"),

   681                 dd )); 

   682                 

   683             TRACE( Print( _L("[FILL MNGR]\t transfer time = %ld"),

   684                 dt ));                                                 

   685             if( dd == KErrNone || dt == KErrNone )

   686                 {

   687                 dd = KCmFmIniDownloadDataAmount;

   688                 dt = KCmFmIniDownloadTime;

   689                 }

   690             // If server hasn't been handled    

   691             if( size != KErrNone )

   692                 {

   693                 transferTime = transferTime + (( dt * size ) / dd );

   694                 }

   695             TRACE( Print( _L("[FILL MNGR]\t avg transfer time = %ld"),

   696                 transferTime ));                            

   697             }

   698              

   699         }

   700     servers.ResetAndDestroy();

   701     CleanupStack::PopAndDestroy( &servers );

   702     

   703     TInt shrinkCount( iDBManager->FillFileCount(ECmToBeShrinked) );

   704         

   705     shrinkTime = (iDBManager->GetAvgImageShrinkTime() * shrinkCount);     

   706     

   707     TInt totalCount( iDBManager->FillFileCount( 

   708         ECmToBeShrinked|ECmToBeFilled ));

   709     transferTime = transferTime + ( shrinkTime / 1000 );

   710     if( KErrNone >= totalCount )

   711         {

   712         transferTime = KErrNone;

   713         }

   714     iDBManager->UpdateTransferInfo( ECmServiceFill, totalCount, 

   715         transferTime );             

   716     }

   717 

   718 // ---------------------------------------------------------------------------

   719 // CCmFmFillRuleFilledDataMngr::SendAvgTransferTime

   720 // ---------------------------------------------------------------------------

   721 //   

   722 void CCmFmFillRuleFilledDataMngr::SendAvgTransferTime()

   723     {

   724     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   725     SendAvgTransferTime()")); 

   726     

   727     // Load transfer information from database

   728     TInt err = iDBManager->GetTransferInfo( ECmServiceFill, 

   729         iTransferInfo.iProcessedItems, iTransferInfo.iTotalItems );

   730         

   731     TRACE( Print( _L("[FILL MNGR]\t GetTransferInfo returned %d"), err));

   732     

   733     TRACE( Print( _L(

   734         "[FILL MNGR]\t item count = %d, avg time = %d"),

   735             iTransferInfo.iProcessedItems, iTransferInfo.iTotalItems ));    

   736     iTransferInfo.iService = ECmServiceTransferInfoFill;

   737         

   738     TCmProgressInfoPckg transferInfoPckg( iTransferInfo );

   739     

   740     err = RProperty::Set( KCmPropertyCat, KCmProperty, 

   741         transferInfoPckg );

   742     

   743     TRACE( Print( _L("[FILL MNGR]\t RProperty::Set returned %d"), err));    

   744     }

   745 

   746 // ---------------------------------------------------------------------------

   747 // CCmFmFillRuleFilledDataMngr::GetMediaServerIdL

   748 // ---------------------------------------------------------------------------

   749 //     

   750 TInt64 CCmFmFillRuleFilledDataMngr::GetMediaServerIdL( const TDesC8& aUuid )

   751     {

   752     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   753     GetMediaServerIdL()")); 

   754     

   755     iDBManager->PrepareQueryCmdL( EMediaServerIdQuery );

   756     return iDBManager->QueryMediaServerId( aUuid ); 

   757     }

   758                 

   759 // ---------------------------------------------------------------------------

   760 // CCmFmFillRuleFilledDataMngr::LoadSelectedFillRulesL

   761 // ---------------------------------------------------------------------------

   762 //    

   763 void CCmFmFillRuleFilledDataMngr::LoadSelectedFillRulesL()

   764     {

   765     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   766         LoadSelectedFillRulesL()"));

   767             

   768     RPointerArray<HBufC8> array;

   769     CleanupClosePushL( array );

   770     

   771     iDBManager->PrepareQueryCmdL( ESelectedFillRuleQuery );    

   772     iDBManager->QuerySelectedFillRuleNamesL( array, (TInt)ECmSelected );

   773     // Load selected fill rules to array ( using names as a query 

   774     // parameter ) 

   775     for( TInt i = 0; i < array.Count(); i++ ) 

   776         {

   777         LoadRuleL( *array[i] );

   778         }

   779     

   780     // Remove random rules. When fill manager is booted up first time 

   781     // Do not remove random rules => need to be processed

   782     // If list don't have any files on the list => process list

   783     for( TInt j = 0; j < iRuleArray.Count(); j++ )

   784         {

   785         if( ECmRandom == iRuleArray[j]->Method() || 

   786             ECmRandomAlbum == iRuleArray[j]->Method() ||

   787             ECmRandomTrack == iRuleArray[j]->Method() )

   788             {

   789             TInt count( KErrNone );

   790             iDBManager->GetFillFileCount(iRuleArray[j]->Name(), 

   791                 ECmToBeFilled|ECmToBeShrinked|ECmFilled|ECmLocalCopy, count );

   792             if( KErrNone < count )

   793                 {

   794                 LOG(_L("[FILL MNGR]\t Random rule is already processed"));

   795                 delete iRuleArray[j];

   796                 iRuleArray.Remove(j);

   797                 j--;                

   798                 }

   799             else

   800                 {

   801                 LOG(_L("[FILL MNGR]\t Random rule is not processed"));

   802                 // Don't remove rule

   803                 }

   804             }

   805         }

   806     for( TInt k = 0; k < iRuleArray.Count(); k++ )

   807         {

   808         if( KErrNone == iRuleArray[k]->MediaServerCount() )

   809             {

   810             LOG(_L("[FILL MNGR]\t No Servers included in fill rule"));

   811             TRACE(Print(_L("[FILL MNGR]\t => Any Server rule...")));

   812             }

   813         }

   814         

   815     array.ResetAndDestroy();

   816     CleanupStack::PopAndDestroy( &array );

   817     

   818     CompleteRequest( EFillRulesLoaded );       

   819     }

   820 

   821 // ---------------------------------------------------------------------------

   822 // CCmFmFillRuleFilledDataMngr::LoadAllFillRulesL

   823 // ---------------------------------------------------------------------------

   824 //

   825 CCmFillRuleContainer* CCmFmFillRuleFilledDataMngr::LoadAllFillRulesL()

   826     {

   827     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::FillRuleContainerL"));

   828     

   829     RPointerArray<HBufC8> array;

   830     CleanupClosePushL( array );

   831     

   832     // Query fill rule names

   833     iDBManager->PrepareQueryCmdL( EFillRuleNamesQuery );

   834     iDBManager->QueryFillRuleNamesL( array );

   835     TRACE(Print(_L("[FILL MNGR]\t fill rule array size is %d"), 

   836         array.Count()));

   837     

   838     CCmFillRuleContainer* ruleContainer = CCmFillRuleContainer::NewLC();

   839     for ( TInt i = 0; i < array.Count(); i++ )

   840         {

   841         // Query all fill rules

   842         CCmFillRule* rule = CCmFillRule::NewLC();

   843         rule->SetNameL( *(array[i]) );

   844         iDBManager->PrepareQueryCmdL( EFillRuleQuery );

   845         iDBManager->QueryFillRuleL( rule );

   846         

   847         ruleContainer->AddFillRuleL( rule );

   848         CleanupStack::Pop( rule );

   849         }

   850     CleanupStack::Pop( ruleContainer );

   851     

   852     array.ResetAndDestroy();

   853     CleanupStack::PopAndDestroy( &array );

   854     

   855     return ruleContainer;

   856     }

   857     

   858 // ---------------------------------------------------------------------------

   859 // CCmFmFillRuleFilledDataMngr::LoadRuleL

   860 // ---------------------------------------------------------------------------

   861 //

   862 void CCmFmFillRuleFilledDataMngr::LoadRuleL( const TDesC8& aFillListName )

   863     {

   864     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadRuleL()")); 

   865     

   866     CCmFillRule* fillRule = CCmFillRule::NewLC();

   867     iDBManager->PrepareQueryCmdL(EFillRuleQuery);

   868     fillRule->SetNameL( aFillListName );

   869     iDBManager->QueryFillRuleL( fillRule );

   870     iRuleArray.AppendL( fillRule );   

   871     iContainer->AddFillRuleL( fillRule );

   872     CleanupStack::Pop( fillRule );

   873     }

   874 

   875 // ---------------------------------------------------------------------------

   876 // CCmFmFillRuleFilledDataMngr::UpdateListItemPriorities

   877 // ---------------------------------------------------------------------------

   878 //

   879 TInt CCmFmFillRuleFilledDataMngr::UpdateListItemPriorities( 

   880     CCmFillRuleContainer* aContainer )

   881     {

   882     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   883     UpdateListItemPriorities()"));

   884      

   885     TInt err( KErrNone );

   886     err = iDBManager->UpdateFillListItemPriority( aContainer );            

   887     TRACE(Print(_L("[FILL MNGR]\t priority update err = %d"), 

   888         err ));            

   889     return err;    

   890     }

   891 

   892 // ---------------------------------------------------------------------------

   893 // CCmFmFillRuleFilledDataMngr::LoadMetadataL

   894 // ---------------------------------------------------------------------------

   895 //    

   896 void CCmFmFillRuleFilledDataMngr::LoadMetadataL( CCmFillRule* aFillRule )

   897     {

   898     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   899     LoadMetadataL()"));

   900     

   901     StartObserverL();    

   902     TRAPD( err, iWrapper->GetFillItemsL( iItems, *aFillRule, iAo->iStatus ) );

   903     if( !err )

   904         {

   905         iQueryStart.HomeTime();

   906         iAo->RunL();

   907         iNewItemCount = iItems.Count();

   908         //add the old item to list

   909         SelectFillListFiles( iOldIds, aFillRule->ListId() );

   910         iProcessingState = ECmFmLoadingMetadata;        

   911         }

   912     else

   913         {

   914         TRACE(Print(_L("[FILL MNGR]\t Metadata find err = %d"), err ));

   915         TRACE(Print(_L("[FILL MNGR]\t Skipping rule...")));

   916         iRuleArray.Remove(0);        

   917         iRuleArray.Compress();   

   918         /** Splitting long task into shorter ones */            

   919         CompleteRequest( ENextFillRule );       

   920         }        

   921     }

   922 

   923 // ---------------------------------------------------------------------------

   924 // CCmFmFillRuleFilledDataMngr::ProcessReferenceValuesL

   925 // ---------------------------------------------------------------------------

   926 // 

   927 void CCmFmFillRuleFilledDataMngr::ProcessReferenceValuesL()

   928     {

   929     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   930     ProcessReferenceValuesL()"));

   931 

   932     DoProcessReferenceValuesL();

   933     CompleteRequest( EProcessStatusValues );             

   934     }

   935 

   936 // ---------------------------------------------------------------------------

   937 // CCmFmFillRuleFilledDataMngr::DoProcessReferenceValuesL

   938 // ---------------------------------------------------------------------------

   939 // 

   940 void CCmFmFillRuleFilledDataMngr::DoProcessReferenceValuesL()

   941     {

   942     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

   943     DoProcessReferenceValuesL()"));

   944     

   945     RArray<TInt> refIds;

   946     CleanupClosePushL( refIds );

   947     

   948     TBool ref( EFalse );

   949     // Processing set referense ids into duplicate items

   950     for( TInt j = 0; j < iItems.Count(); j++ )

   951         {                       

   952         for( TInt k = iItems.Count() - 1; k >= KErrNone; k-- )

   953             {

   954             if( ( KErrNone == iItems[k]->PrimaryText().Compare(

   955                 iItems[j]->PrimaryText() )) && (iItems[k]->Size() 

   956                == iItems[j]->Size() ) && ( j != k ) && 

   957                     ( ECmSelected == iItems[j]->Selected() || 

   958                     ( ECmUnSelected == iItems[j]->Selected() && 

   959                     ECmUnSelected == iItems[k]->Selected() ) ) )

   960                 {

   961                 if( iItems[k]->Priority() > iItems[j]->Priority() )

   962                     {

   963                     refIds.InsertInOrderL( k );

   964                     }

   965                 else if ( iItems[k]->Priority() < iItems[j]->Priority() )

   966                     {

   967                     // Some of the items are on the higher priority than

   968                     // iItems[ j ]

   969                     if( ECmUnSelected == iItems[k]->Selected() && 

   970                         ECmSelected == iItems[j]->Selected() )

   971                         {

   972                         refIds.InsertInOrderL( k );

   973                         }

   974                     else

   975                         {

   976                         ref = ETrue;

   977                         }    

   978                     }

   979                 }

   980             // Check if there is a match on a selected list    

   981             if( ( KErrNone == iItems[k]->PrimaryText().Compare(

   982                 iItems[j]->PrimaryText() ) ) && ( iItems[k]->Size() 

   983                == iItems[j]->Size() ) && ( j != k ) && 

   984                     ( ECmUnSelected == iItems[j]->Selected() && 

   985                     ECmSelected == iItems[k]->Selected() ) && ( 

   986                     iItems[k]->Priority() < iItems[j]->Priority() ) )

   987                 {

   988                 // Do not set ref id to zero

   989                 ref = ETrue;

   990                 }

   991             }

   992         // Updating referense ids    

   993         for( TInt i = 0; i < refIds.Count(); i++ )

   994             {

   995             iItems[refIds[i]]->SetRefId( iItems[j]->DbId() );

   996             }

   997         if( !ref )

   998             {

   999             iItems[j]->SetRefId( 0 );

  1000             }

  1001         ref = EFalse;    

  1002         refIds.Reset();    

  1003         }

  1004     

  1005     CleanupStack::PopAndDestroy( &refIds );                     

  1006     }

  1007 

  1008 // ---------------------------------------------------------------------------

  1009 // CCmFmFillRuleFilledDataMngr::ProcessDuplicates

  1010 // Processes duplicates. If same list has some item twice,

  1011 // newer one is removed from the list

  1012 // ---------------------------------------------------------------------------

  1013 //

  1014 void CCmFmFillRuleFilledDataMngr::ProcessDuplicates()

  1015     {

  1016     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

  1017     ProcessDuplicates()"));

  1018 

  1019     TBool duplicateFound( EFalse );

  1020     

  1021     for( TInt i = 0; i < iFileIds.Count() - 1; i++ )

  1022         {

  1023         duplicateFound = EFalse;

  1024         //Compare item with following items 

  1025         for( TInt j = i+1; j < iFileIds.Count() && !duplicateFound; j++ )

  1026             {

  1027             if( ( iFileIds[i] < iItems.Count() ) && 

  1028                 ( iFileIds[j] < iItems.Count() ) )

  1029                 {

  1030                 if( i != j && ( ( KErrNone == iItems[iFileIds[i]]->

  1031                     PrimaryText().Compare( 

  1032                     iItems[iFileIds[j]]->PrimaryText() ) ) 

  1033                     && ( iItems[iFileIds[i]]->Size() == 

  1034                     iItems[iFileIds[j]]->Size() ) || 

  1035                     iItems[iFileIds[i]]->DbId() == 

  1036                     iItems[iFileIds[j]]->DbId() ) ) 

  1037                     {

  1038                     if( ( ECmImage == iItems[iFileIds[j]]->MediaType() &&

  1039                          ECmToBeShrinked == iItems[iFileIds[i]]->Status()) ||

  1040                         ( ECmImage == iItems[iFileIds[j]]->MediaType() &&

  1041                           ECmToBeFilled == iItems[iFileIds[i]]->Status()) )

  1042 	                    {

  1043 	                    // if the media type is image and never be filled

  1044 	                    //before ,so do not change the new items status value

  1045 	                    //in this cycle , just delete the old items 	

  1046 	                    }

  1047 	                else

  1048 	                    {

  1049 	                    iItems[iFileIds[j]]->SetStatus( 

  1050                             iItems[iFileIds[i]]->Status() ) ;	

  1051 	                    }

  1052                     TRAP_IGNORE( iItems[iFileIds[j]]->SetPathL( 

  1053                         iItems[iFileIds[i]]->Path() ) );

  1054                     iItems[iFileIds[j]]->SetDriveId( 

  1055                         iItems[iFileIds[i]]->DriveId() );

  1056                     iItems[iFileIds[j]]->SetDriveNumber( 

  1057                         iItems[iFileIds[i]]->DriveNumber() );                                           

  1058 

  1059                     duplicateFound = ETrue;

  1060                     }                

  1061                 }                           

  1062             }

  1063         //iItems[iFileIds[i]] is duplicated, should delete it

  1064         if( duplicateFound )

  1065             {

  1066             DoDeleteProcess( iFileIds[i] );

  1067             i--;

  1068             }

  1069         }  

  1070     iItems.Compress();

  1071      

  1072     /** Spliting long task into shorter ones */            

  1073     CompleteRequest( EProcessReferenceValues );

  1074     }

  1075 

  1076 // ---------------------------------------------------------------------------

  1077 // CCmFmFillRuleFilledDataMngr::SelectFillListFiles

  1078 // ---------------------------------------------------------------------------

  1079 //    

  1080 void CCmFmFillRuleFilledDataMngr::SelectFillListFiles( RArray<TInt>& aList,

  1081                                                        TUint8 aId )

  1082     {

  1083     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

  1084     SelectFillListFiles()"));

  1085     

  1086     TRACE(Print(_L("[FILL MNGR]\t LIST ID = %d"), aId ));

  1087     aList.Reset();

  1088     aList.Close();

  1089     TInt count( iItems.Count() );

  1090     for( TInt i = 0; i < count; i++ )

  1091         {

  1092         if( iItems[i]->ListId() == aId )

  1093             {

  1094             aList.InsertInOrderL( i );

  1095             }

  1096         }    

  1097     }

  1098 

  1099 // ---------------------------------------------------------------------------

  1100 // CCmFmFillRuleFilledDataMngr::ProcessFileStatusValuesL

  1101 // ---------------------------------------------------------------------------

  1102 //

  1103 void CCmFmFillRuleFilledDataMngr::ProcessFileStatusValuesL()

  1104     {

  1105     LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\

  1106     ProcessFileStatusValuesL()"));

  1107     

  1108     // Let's update priorities,is it possible that priority has changed

  1109     // And list ids

  1110     TInt64 ruleSize( KErrNone );

  1111     TInt64 realSize( KErrNone );

  1112     TInt err( KErrNone );

  1113     if( iRuleArray.Count() > 0 )

  1114 	    {

  1115 	    TRAP( err, iDBManager->SetFillListRealCountAndSizeL( 

  1116 	        iRuleArray[0]->ListId(), 0, 0 ) );	

  1117 	    }

  1118    

  1119     TRACE(Print(_L("[FILL MNGR]\t Size set err = %d"), 

  1120         err ));                    

  1121     TInt64 realCount( iFileIds.Count() );

  1122     for( TInt k = ( iFileIds.Count() - 1 ); k >= KErrNone && 

  1123         iFileIds[k] < iItems.Count() ; k-- )

  1124         {

  1125         // Update priority

  1126         iItems[iFileIds[k]]->SetPriority( iRuleArray[0]->Priority() );

  1127         // Update list id

  1128         iItems[iFileIds[k]]->SetListId( iRuleArray[0]->ListId() );        

  1129         if ( iItems[iFileIds[k]]->Status() == ECmToBeFilled || 

  1130             iItems[iFileIds[k]]->Status() == ECmToBeShrinked ||

  1131             iItems[iFileIds[k]]->Status() == ECmFilled ||

  1132             iItems[iFileIds[k]]->Status() == ECmLocalCopy )

  1133             {

  1134             // increases list size