diff -r 000000000000 -r 7f85d04be362 homesync/contentmanager/cmserver/cmfillmanager/src/cmfmfillrulefilleddatamngr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/homesync/contentmanager/cmserver/cmfillmanager/src/cmfmfillrulefilleddatamngr.cpp Thu Dec 17 08:52:00 2009 +0200 @@ -0,0 +1,1686 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Fill rule and filled data processing +* Version : %version: tr1ido#17 % << Don't touch! +* +*/ + + + +#include +#include "upnpdlnautility.h" +#include "cmsqlmainfactory.h" +#include "mcmsqlmain.h" +#include "cmdmmain.h" +#include "cmfillrule.h" +#include "cmfillrulecontainer.h" +#include "cmsqlpropertyitem.h" +#include "cmmediaserverfull.h" +#include "cmfilllistitem.h" +#include "cmfmmain.h" +#include "cmfmao.h" +#include "cmfmfillrulefilleddatamngr.h" +#include "msdebug.h" + +// Constants +const TInt KCmFmIniDownloadDataAmount = 300; // 300 kBs +const TInt KCmFmIniDownloadTime = 1; // One second + + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::NewL +// --------------------------------------------------------------------------- +// +CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewL( + MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr, + RPointerArray& aItems ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() start")); + CCmFmFillRuleFilledDataMngr* self = CCmFmFillRuleFilledDataMngr::NewLC( + aObserver, aDBMngr, aItems ); + CleanupStack::Pop( self ); + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewL() end")); + return self; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::NewLC +// --------------------------------------------------------------------------- +// +CCmFmFillRuleFilledDataMngr* CCmFmFillRuleFilledDataMngr::NewLC( + MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr, + RPointerArray& aItems ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() start")); + CCmFmFillRuleFilledDataMngr* self = + new ( ELeave ) CCmFmFillRuleFilledDataMngr( aObserver, aDBMngr, + aItems ); + CleanupStack::PushL( self ); + self->ConstructL(); + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::NewLC() end")); + return self; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr +// --------------------------------------------------------------------------- +// +CCmFmFillRuleFilledDataMngr::~CCmFmFillRuleFilledDataMngr() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ~CCmFmFillRuleFilledDataMngr() start")); + Cancel(); + + if ( iWrapper ) + { + iWrapper->Close(); + } + + if ( iAo ) + { + delete iAo; + } + + iObserver = NULL; + iDBManager = NULL; + + if ( iContainer ) + { + delete iContainer; + } + + iRuleArray.Reset(); + iRuleArray.Close(); + + iUpdateItems.Reset(); + iUpdateItems.Close(); + + iPropertys.ResetAndDestroy(); + + iFileIds.Close(); + iMetadataServersToBeDeleted.Close(); + iOldIds.Close(); + iFs.Close(); + iFilteredProfiles.Reset(); + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ~CCmFmFillRuleFilledDataMngr() end")); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr +// --------------------------------------------------------------------------- +// +CCmFmFillRuleFilledDataMngr::CCmFmFillRuleFilledDataMngr( + MCmFmFillRuleObserver* aObserver, CCmDmMain* aDBMngr, + RPointerArray& aItems ) + :CActive( EPriorityStandard ), iObserver( aObserver ), + iDBManager( aDBMngr ), iItems(aItems) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + CCmFmFillRuleFilledDataMngr()")); + + CActiveScheduler::Add( this ); + iTransferInfo.iService = ECmServiceTransferInfoFill; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ConstructL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ConstructL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::ConstructL()")); + User::LeaveIfError( iFs.Connect() ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::OperationCompletedL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::OperationCompletedL( TInt aStatus ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + OperationCompletedL()")); + + iQueryFinished.HomeTime(); + TTimeIntervalMicroSeconds usecsFrom = + iQueryFinished.MicroSecondsFrom( iQueryStart ); + TRACE(Print(_L("[FILL MNGR]\t Query \ + took = %ld mseconds"), ( usecsFrom.Int64() / 1000 ) )); + + if( KErrNone == aStatus ) + { + switch( iProcessingState ) + { + case ECmFmLoadingPropertys: + { + // Loading propertys ready + CompleteRequest( EColumnDataReady ); + break; + } + case ECmFmLoadingMetadata: + { + // Loading file metadata ready ( for one fill list ) + iNewItemCount = iItems.Count() - iNewItemCount; + CompleteRequest( EQueryCompleted ); + break; + } + case ECmFmDeletingMetadata: + { + // Metadata deleted from defined media servers + TRAPD( err, DeleteHashCodesL() ); + iMetadataServersToBeDeleted.Reset(); + iMetadataServersToBeDeleted.Close(); + iWrapper->DeleteUnusedPropertys( ); + if( !err ) + { + CompleteRequest( EMetadataDeleted ); + } + else + { + TRACE(Print(_L("[FILL MNGR]\t \ + OperationCompletedL err %d "), err )); + } + break; + } + case ECmFmLoadingProfileIds: + { + DefineAndSetDlnaProfileIdFiltersL(); + PreprocessListsL(); + break; + } + default: + { + LOG(_L("[FILL MNGR]\t OperationCompletedL processing \ + state not found")); + break; + } + } + } + else + { + TRACE(Print(_L("[FILL MNGR]\t OperationCompletedL aStatus = %d"), + aStatus )); + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadProfileIdsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::LoadProfileIdsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadProfileIdsL()")); + // Loads all dlna profile ids from database. Profile ids are used + // to filter out unsupported media types + iPropertys.ResetAndDestroy(); + iProcessingState = ECmFmLoadingProfileIds; + CreateWrapperL(); + StartObserverL(); + iWrapper->GetPropertyValuesL( iPropertys, iAo->iStatus, + ECmProfileId, ECmAll ); + iQueryStart.HomeTime(); + iAo->RunL(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::PreprocessListsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::PreprocessListsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreprocessListsL()")); + +#ifdef _DEBUG + TInt alloc; + TInt cells = User::Heap().AllocSize( alloc ); + TInt size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t preprocess heap allocsize %d, \ + size %d, cells %d"), alloc, size, cells )); +#endif + iProcessingState = ECmFmIdle; + ResetData(); + // Creates sqlite wrapper and starts preprocessing of all fill lists + TRAP_IGNORE( CreateWrapperL() ); + iTransferInfo.iTotalItems = KErrNone; + iTransferInfo.iProcessedItems = KErrNone; + CompleteRequest( EPreProcessingStarted ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::PreProcessListL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::PreProcessListL( + const TDesC8& aFillListName ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::PreProcessListL()")); + + iProcessingState = ECmFmIdle; + // Creates sqlite wrapper and starts preprocessing of + // one defined fill list + CreateWrapperL(); + ResetData(); + iContainer = CCmFillRuleContainer::NewL(); + LoadRuleL( aFillListName ); + LoadAllFillItemsL(); + CompleteRequest( ERandomizingStarted ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetColItemsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::GetColItemsL( TCmMetadataField aType, + TCmMediaType aMedia, CCmSqlPropertyContainer& aPropertys ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetColItemsL()")); + + iPropertyContainer = NULL; + iPropertyContainer = &aPropertys; + iPropertys.ResetAndDestroy(); + iProcessingState = ECmFmLoadingPropertys; + CreateWrapperL(); + StartObserverL(); + // starts loading defined propertys from database + iWrapper->GetPropertyValuesL(iPropertys, iAo->iStatus, aType, aMedia ); + iQueryStart.HomeTime(); + iAo->RunL(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetMetadataItemsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::GetMetadataItemsL( + CCmSqlPropertyCollector& aPropertys ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + GetMetadataItemsL()")); + + iPropertyCollector = NULL; + iPropertyCollector = &aPropertys; + iProcessingState = ECmFmLoadingPropertys; + CreateWrapperL(); + StartObserverL(); + // starts loading property values. Selected artists, albums, genres and + // tracks are used as a filtering parameter ( e.g. if some artist is + // selected, only albums for that defined artist are loaded. + iWrapper->GetFilteredPropertyValuesL( *iPropertyCollector, iAo->iStatus ); + iQueryStart.HomeTime(); + iAo->RunL(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::UpdatePriorities +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::UpdatePriorities() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::UpdatePriorities()")); + + CompleteRequest( EUpdatePriorities ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DoUpdatePrioritiesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + DoUpdatePrioritiesL()")); + + // Updating first list item priorities +#ifdef _DEBUG + TInt alloc; + TInt cells = User::Heap().AllocSize( alloc ); + TInt size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL start heap \ + allocsize %d, size %d, cells %d"), alloc, size, cells )); +#endif + + CCmFillRuleContainer* container = LoadAllFillRulesL(); + CleanupStack::PushL( container ); + TInt err( UpdateListItemPriorities( container ) ); + TRACE(Print(_L("[FILL MNGR]\t UpdateListItemPriorities err = %d"), + err )); + CleanupStack::PopAndDestroy(container); + CalculateAvgTransferTimeL(); + SendAvgTransferTime(); + +#ifdef _DEBUG + cells = User::Heap().AllocSize( alloc ); + size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t DoUpdatePrioritiesL end heap \ + allocsize %d, size %d, cells %d"), alloc, size, cells )); +#endif + + iObserver->FillRuleProcessingStatus( EDoUpdatePriorities ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DoUpdateReferenceIdsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + DoUpdateReferenceIdsL()")); + +#ifdef _DEBUG + TInt alloc; + TInt cells = User::Heap().AllocSize( alloc ); + TInt size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL start heap \ + allocsize %d, size %d, cells %d"), alloc, size, cells )); +#endif + + LoadAllFillItemsL(); + LOG(_L("[FILL MNGR]\t Items loaded...")); + + // Processing set referense ids into duplicate items + LOG(_L("[FILL MNGR]\t Processing ref ids...")); + + DoProcessReferenceValuesL(); + + LOG(_L("[FILL MNGR]\t Ref ids processed...")); + UpdateFillItems(); + iItems.ResetAndDestroy(); + iItems.Close(); +#ifdef _DEBUG + cells = User::Heap().AllocSize( alloc ); + size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t DoUpdateReferenceIdsL end heap \ + allocsize %d, size %d, cells %d"), alloc, size, cells )); +#endif + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DeleteMetadataL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DeleteMetadataL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DeleteMetadataL()")); + + iMetadataServersToBeDeleted.Reset(); + + RPointerArray mediaServers; + CleanupClosePushL( mediaServers ); + + iDBManager->GetMediaServersL( mediaServers ); + + TBool setSystemUpdateIDChange( EFalse ); + for( TInt i = 0; i < mediaServers.Count(); i++ ) + { + // checks that server is either inactive or deleted + if( mediaServers[i]->DbId() != 0 && + !( mediaServers[i]->FillUsage() ) ) + { + iMetadataServersToBeDeleted.Append( mediaServers[i]->DbId() ); + TRACE(Print(_L("[FILL MNGR]\t DbId = %ld"), + mediaServers[i]->DbId() )); + + mediaServers[i]->SetSystemUpdateID( KErrNotFound ); + + setSystemUpdateIDChange = ETrue; + } + } + + if ( setSystemUpdateIDChange ) + { + iDBManager->SetMediaServersL( mediaServers ); + } + + mediaServers.ResetAndDestroy(); + CleanupStack::PopAndDestroy( &mediaServers ); + + iProcessingState = ECmFmDeletingMetadata; + CreateWrapperL(); + StartObserverL(); + iWrapper->AsyncMetadataDelete( iMetadataServersToBeDeleted, + iAo->iStatus ); + iQueryStart.HomeTime(); + iAo->RunL(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::SetMemoryCardQuota( TInt64 aQuota ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + SetMemoryCardQuota()")); + + if( iWrapper ) + { + iWrapper->SetQuota( aQuota ); + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CancelOperation +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::CancelOperation() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CancelOperation()")); + + Cancel(); + if( iWrapper ) + { + iWrapper->CancelAsyncOperation(); + } + DeleteWrapper(); + if( iAo ) + { + if( iAo->IsActive() ) + { + iAo->Cancel(); + } + delete iAo; + iAo = NULL; + } + LOG(_L("[FILL MNGR]\t iAo canceled...")); + iObserver->FillRuleProcessingStatus(EProcessingCanceled); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::UpdateTransferHistoryData( + TInt64 aInterval, TInt64 aDataAmount, + TUint8 aServerId ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + UpdateTransferHistoryData()")); + + iDBManager->UpdateDownloadHistory( (TUint)aServerId, aDataAmount, + aInterval ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetFillItemsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::GetFillItemsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetFillItemsL()")); + + iItems.ResetAndDestroy(); + iItems.Close(); + iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery); + iDBManager->GetAllFillFilesL( iItems, + ECmToBeShrinked|ECmToBeFilled|ECmFilled|ECmLocalCopy ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetToBeDeletedL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::GetToBeDeletedL( + RPointerArray& aArray ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetToBeDeletedL()")); + + iDBManager->PrepareQueryCmdL(EAllFillFilesStatusQuery); + iDBManager->GetAllFillFilesL( aArray, ECmToBeRemoved ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::UpdateFillItems +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::UpdateFillItems( TBool aCancel ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::UpdateFillItems()")); + + iDBManager->DeleteFillFiles(); + if( aCancel && iUpdateItems.Count() ) + { + iDBManager->SetFillFiles( iUpdateItems ); + } + else + { + iDBManager->SetFillFiles( iItems ); + } + iUpdateItems.Reset(); + iUpdateItems.Close(); + + iItems.ResetAndDestroy(); + iItems.Close(); + + TRAP_IGNORE( CalculateAvgTransferTimeL() ); + SendAvgTransferTime(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::UpdateToBeDeleted +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::UpdateToBeDeleted( + RPointerArray& aArray ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + UpdateToBeDeleted()")); + + // This function is needed when fill is processed only partially + // Some of the to be deleted files are still on device + iDBManager->SetFillFiles( aArray ); + aArray.ResetAndDestroy(); + aArray.Close(); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetUuidL +// --------------------------------------------------------------------------- +// +TInt CCmFmFillRuleFilledDataMngr::GetUuidL( HBufC8*& aUuid, TUint8 aId ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::GetUuidL()")); + + iDBManager->PrepareQueryCmdL( EMediaServerUDNQuery ); + return iDBManager->QueryMediaServerUdn(aUuid, aId); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ResetData +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ResetData() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::ResetData()")); + + iNewItemCount = KErrNone; + + iRuleArray.Reset(); + iRuleArray.Close(); + + iUpdateItems.Reset(); + iUpdateItems.Close(); + + iItems.ResetAndDestroy(); + iItems.Close(); + + iFileIds.Close(); + iOldIds.Close(); + + if( iContainer ) + { + delete iContainer; + iContainer = NULL; + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CalculateAvgTransferTimeL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::CalculateAvgTransferTimeL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + CalculateAvgTransferTimeL()")); + + TInt64 ud(KErrNone); + TInt64 dd(KErrNone); + TInt64 ut(KErrNone); + TInt64 dt(KErrNone); + TInt64 size( KErrNone ); + TInt64 shrinkTime(KErrNone); + TInt64 transferTime(KErrNone); + TInt ret( KErrNone ); + RPointerArray servers; + CleanupClosePushL( servers ); + + iDBManager->PrepareQueryCmdL( EMediaServersAllQuery ); + while( !ret ) + { + CCmMediaServerFull* server = CCmMediaServerFull::NewLC(); + ret = iDBManager->QueryAllMediaServersL( server ); + if( !ret ) + { + servers.Append( server ); + CleanupStack::Pop( server ); + } + else + { + CleanupStack::PopAndDestroy( server ); + } + } + TRACE( Print( _L("[FILL MNGR]\t servers.Count() = %d"), + servers.Count() )); + for( TInt i = 0; i < servers.Count(); i++ ) + { + iDBManager->PrepareQueryCmdL(ETransferHistoryQuery); + TPtrC8 ser( servers[i]->MediaServer() ); + if( &ser ) + { + iDBManager->QueryTransferHistory( + ser, dd, ud, dt, ut ); + size = iDBManager->KBytesToBeFilled( + GetMediaServerIdL(ser), + ECmToBeShrinked|ECmToBeFilled ); + TRACE( Print( _L("[FILL MNGR]\t data amount \ + to be filled = %ld"), size )); + + TRACE( Print( _L("[FILL MNGR]\t transferred data = %ld"), + dd )); + + TRACE( Print( _L("[FILL MNGR]\t transfer time = %ld"), + dt )); + if( dd == KErrNone || dt == KErrNone ) + { + dd = KCmFmIniDownloadDataAmount; + dt = KCmFmIniDownloadTime; + } + // If server hasn't been handled + if( size != KErrNone ) + { + transferTime = transferTime + (( dt * size ) / dd ); + } + TRACE( Print( _L("[FILL MNGR]\t avg transfer time = %ld"), + transferTime )); + } + + } + servers.ResetAndDestroy(); + CleanupStack::PopAndDestroy( &servers ); + + TInt shrinkCount( iDBManager->FillFileCount(ECmToBeShrinked) ); + + shrinkTime = (iDBManager->GetAvgImageShrinkTime() * shrinkCount); + + TInt totalCount( iDBManager->FillFileCount( + ECmToBeShrinked|ECmToBeFilled )); + transferTime = transferTime + ( shrinkTime / 1000 ); + if( KErrNone >= totalCount ) + { + transferTime = KErrNone; + } + iDBManager->UpdateTransferInfo( ECmServiceFill, totalCount, + transferTime ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::SendAvgTransferTime +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::SendAvgTransferTime() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + SendAvgTransferTime()")); + + // Load transfer information from database + TInt err = iDBManager->GetTransferInfo( ECmServiceFill, + iTransferInfo.iProcessedItems, iTransferInfo.iTotalItems ); + + TRACE( Print( _L("[FILL MNGR]\t GetTransferInfo returned %d"), err)); + + TRACE( Print( _L( + "[FILL MNGR]\t item count = %d, avg time = %d"), + iTransferInfo.iProcessedItems, iTransferInfo.iTotalItems )); + iTransferInfo.iService = ECmServiceTransferInfoFill; + + TCmProgressInfoPckg transferInfoPckg( iTransferInfo ); + + err = RProperty::Set( KCmPropertyCat, KCmProperty, + transferInfoPckg ); + + TRACE( Print( _L("[FILL MNGR]\t RProperty::Set returned %d"), err)); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::GetMediaServerIdL +// --------------------------------------------------------------------------- +// +TInt64 CCmFmFillRuleFilledDataMngr::GetMediaServerIdL( const TDesC8& aUuid ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + GetMediaServerIdL()")); + + iDBManager->PrepareQueryCmdL( EMediaServerIdQuery ); + return iDBManager->QueryMediaServerId( aUuid ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadSelectedFillRulesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::LoadSelectedFillRulesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + LoadSelectedFillRulesL()")); + + RPointerArray array; + CleanupClosePushL( array ); + + iDBManager->PrepareQueryCmdL( ESelectedFillRuleQuery ); + iDBManager->QuerySelectedFillRuleNamesL( array, (TInt)ECmSelected ); + // Load selected fill rules to array ( using names as a query + // parameter ) + for( TInt i = 0; i < array.Count(); i++ ) + { + LoadRuleL( *array[i] ); + } + + // Remove random rules. When fill manager is booted up first time + // Do not remove random rules => need to be processed + // If list don't have any files on the list => process list + for( TInt j = 0; j < iRuleArray.Count(); j++ ) + { + if( ECmRandom == iRuleArray[j]->Method() || + ECmRandomAlbum == iRuleArray[j]->Method() || + ECmRandomTrack == iRuleArray[j]->Method() ) + { + TInt count( KErrNone ); + iDBManager->GetFillFileCount(iRuleArray[j]->Name(), + ECmToBeFilled|ECmToBeShrinked|ECmFilled|ECmLocalCopy, count ); + if( KErrNone < count ) + { + LOG(_L("[FILL MNGR]\t Random rule is already processed")); + delete iRuleArray[j]; + iRuleArray.Remove(j); + j--; + } + else + { + LOG(_L("[FILL MNGR]\t Random rule is not processed")); + // Don't remove rule + } + } + } + for( TInt k = 0; k < iRuleArray.Count(); k++ ) + { + if( KErrNone == iRuleArray[k]->MediaServerCount() ) + { + LOG(_L("[FILL MNGR]\t No Servers included in fill rule")); + TRACE(Print(_L("[FILL MNGR]\t => Any Server rule..."))); + } + } + + array.ResetAndDestroy(); + CleanupStack::PopAndDestroy( &array ); + + CompleteRequest( EFillRulesLoaded ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadAllFillRulesL +// --------------------------------------------------------------------------- +// +CCmFillRuleContainer* CCmFmFillRuleFilledDataMngr::LoadAllFillRulesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::FillRuleContainerL")); + + RPointerArray array; + CleanupClosePushL( array ); + + // Query fill rule names + iDBManager->PrepareQueryCmdL( EFillRuleNamesQuery ); + iDBManager->QueryFillRuleNamesL( array ); + TRACE(Print(_L("[FILL MNGR]\t fill rule array size is %d"), + array.Count())); + + CCmFillRuleContainer* ruleContainer = CCmFillRuleContainer::NewLC(); + for ( TInt i = 0; i < array.Count(); i++ ) + { + // Query all fill rules + CCmFillRule* rule = CCmFillRule::NewLC(); + rule->SetNameL( *(array[i]) ); + iDBManager->PrepareQueryCmdL( EFillRuleQuery ); + iDBManager->QueryFillRuleL( rule ); + + ruleContainer->AddFillRuleL( rule ); + CleanupStack::Pop( rule ); + } + CleanupStack::Pop( ruleContainer ); + + array.ResetAndDestroy(); + CleanupStack::PopAndDestroy( &array ); + + return ruleContainer; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadRuleL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::LoadRuleL( const TDesC8& aFillListName ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadRuleL()")); + + CCmFillRule* fillRule = CCmFillRule::NewLC(); + iDBManager->PrepareQueryCmdL(EFillRuleQuery); + fillRule->SetNameL( aFillListName ); + iDBManager->QueryFillRuleL( fillRule ); + iRuleArray.Append( fillRule ); + iContainer->AddFillRuleL( fillRule ); + CleanupStack::Pop( fillRule ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::UpdateListItemPriorities +// --------------------------------------------------------------------------- +// +TInt CCmFmFillRuleFilledDataMngr::UpdateListItemPriorities( + CCmFillRuleContainer* aContainer ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + UpdateListItemPriorities()")); + + TInt err( KErrNone ); + err = iDBManager->UpdateFillListItemPriority( aContainer ); + TRACE(Print(_L("[FILL MNGR]\t priority update err = %d"), + err )); + return err; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadMetadataL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::LoadMetadataL( CCmFillRule* aFillRule ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + LoadMetadataL()")); + + StartObserverL(); + TRAPD( err, iWrapper->GetFillItemsL( iItems, *aFillRule, iAo->iStatus ) ); + if( !err ) + { + iQueryStart.HomeTime(); + iAo->RunL(); + iNewItemCount = iItems.Count(); + //add the old item to list + SelectFillListFiles( iOldIds, aFillRule->ListId() ); + iProcessingState = ECmFmLoadingMetadata; + } + else + { + TRACE(Print(_L("[FILL MNGR]\t Metadata find err = %d"), err )); + TRACE(Print(_L("[FILL MNGR]\t Skipping rule..."))); + iRuleArray.Remove(0); + iRuleArray.Compress(); + /** Splitting long task into shorter ones */ + CompleteRequest( ENextFillRule ); + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ProcessReferenceValuesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ProcessReferenceValuesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ProcessReferenceValuesL()")); + + DoProcessReferenceValuesL(); + CompleteRequest( EProcessStatusValues ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DoProcessReferenceValuesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DoProcessReferenceValuesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + DoProcessReferenceValuesL()")); + + RArray refIds; + CleanupClosePushL( refIds ); + + TBool ref( EFalse ); + // Processing set referense ids into duplicate items + for( TInt j = 0; j < iItems.Count(); j++ ) + { + for( TInt k = iItems.Count() - 1; k >= KErrNone; k-- ) + { + if( ( KErrNone == iItems[k]->PrimaryText().Compare( + iItems[j]->PrimaryText() )) && (iItems[k]->Size() + == iItems[j]->Size() ) && ( j != k ) && + ( ECmSelected == iItems[j]->Selected() || + ( ECmUnSelected == iItems[j]->Selected() && + ECmUnSelected == iItems[k]->Selected() ) ) ) + { + if( iItems[k]->Priority() > iItems[j]->Priority() ) + { + refIds.InsertInOrder( k ); + } + else if ( iItems[k]->Priority() < iItems[j]->Priority() ) + { + // Some of the items are on the higher priority than + // iItems[ j ] + if( ECmUnSelected == iItems[k]->Selected() && + ECmSelected == iItems[j]->Selected() ) + { + refIds.InsertInOrder( k ); + } + else + { + ref = ETrue; + } + } + } + // Check if there is a match on a selected list + if( ( KErrNone == iItems[k]->PrimaryText().Compare( + iItems[j]->PrimaryText() ) ) && ( iItems[k]->Size() + == iItems[j]->Size() ) && ( j != k ) && + ( ECmUnSelected == iItems[j]->Selected() && + ECmSelected == iItems[k]->Selected() ) && ( + iItems[k]->Priority() < iItems[j]->Priority() ) ) + { + // Do not set ref id to zero + ref = ETrue; + } + } + // Updating referense ids + for( TInt i = 0; i < refIds.Count(); i++ ) + { + iItems[refIds[i]]->SetRefId( iItems[j]->DbId() ); + } + if( !ref ) + { + iItems[j]->SetRefId( 0 ); + } + ref = EFalse; + refIds.Reset(); + } + + CleanupStack::PopAndDestroy( &refIds ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ProcessDuplicates +// Processes duplicates. If same list has some item twice, +// newer one is removed from the list +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ProcessDuplicates() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ProcessDuplicates()")); + + TBool duplicateFound( EFalse ); + + for( TInt i = 0; i < iFileIds.Count() - 1; i++ ) + { + duplicateFound = EFalse; + //Compare item with following items + for( TInt j = i+1; j < iFileIds.Count() && !duplicateFound; j++ ) + { + if( ( iFileIds[i] < iItems.Count() ) && + ( iFileIds[j] < iItems.Count() ) ) + { + if( i != j && ( ( KErrNone == iItems[iFileIds[i]]-> + PrimaryText().Compare( + iItems[iFileIds[j]]->PrimaryText() ) ) + && ( iItems[iFileIds[i]]->Size() == + iItems[iFileIds[j]]->Size() ) || + iItems[iFileIds[i]]->DbId() == + iItems[iFileIds[j]]->DbId() ) ) + { + if( ( ECmImage == iItems[iFileIds[j]]->MediaType() && + ECmToBeShrinked == iItems[iFileIds[i]]->Status()) || + ( ECmImage == iItems[iFileIds[j]]->MediaType() && + ECmToBeFilled == iItems[iFileIds[i]]->Status()) ) + { + // if the media type is image and never be filled + //before ,so do not change the new items status value + //in this cycle , just delete the old items + } + else + { + iItems[iFileIds[j]]->SetStatus( + iItems[iFileIds[i]]->Status() ) ; + } + TRAP_IGNORE( iItems[iFileIds[j]]->SetPathL( + iItems[iFileIds[i]]->Path() ) ); + iItems[iFileIds[j]]->SetDriveId( + iItems[iFileIds[i]]->DriveId() ); + iItems[iFileIds[j]]->SetDriveNumber( + iItems[iFileIds[i]]->DriveNumber() ); + + duplicateFound = ETrue; + } + } + } + //iItems[iFileIds[i]] is duplicated, should delete it + if( duplicateFound ) + { + DoDeleteProcess( iFileIds[i] ); + i--; + } + } + iItems.Compress(); + + /** Spliting long task into shorter ones */ + CompleteRequest( EProcessReferenceValues ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::SelectFillListFiles +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::SelectFillListFiles( RArray& aList, + TUint8 aId ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + SelectFillListFiles()")); + + TRACE(Print(_L("[FILL MNGR]\t LIST ID = %d"), aId )); + aList.Reset(); + aList.Close(); + TInt count( iItems.Count() ); + for( TInt i = 0; i < count; i++ ) + { + if( iItems[i]->ListId() == aId ) + { + aList.InsertInOrder( i ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ProcessFileStatusValuesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ProcessFileStatusValuesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ProcessFileStatusValuesL()")); + + // Let's update priorities,is it possible that priority has changed + // And list ids + TInt64 ruleSize( KErrNone ); + TInt64 realSize( KErrNone ); + TInt err( KErrNone ); + if( iRuleArray.Count() > 0 ) + { + TRAP( err, iDBManager->SetFillListRealCountAndSizeL( + iRuleArray[0]->ListId(), 0, 0 ) ); + } + + TRACE(Print(_L("[FILL MNGR]\t Size set err = %d"), + err )); + TInt64 realCount( iFileIds.Count() ); + for( TInt k = ( iFileIds.Count() - 1 ); k >= KErrNone && + iFileIds[k] < iItems.Count() ; k-- ) + { + // Update priority + iItems[iFileIds[k]]->SetPriority( iRuleArray[0]->Priority() ); + // Update list id + iItems[iFileIds[k]]->SetListId( iRuleArray[0]->ListId() ); + if ( iItems[iFileIds[k]]->Status() == ECmToBeFilled || + iItems[iFileIds[k]]->Status() == ECmToBeShrinked || + iItems[iFileIds[k]]->Status() == ECmFilled || + iItems[iFileIds[k]]->Status() == ECmLocalCopy ) + { + // increases list size + realSize += iItems[iFileIds[k]]->Size(); + } + + else if ( iItems[iFileIds[k]]->Status() == ECmToBeRemoved ) + { + // reduces list size + realCount--; + } + + ruleSize = ruleSize + iItems[iFileIds[k]]->Size(); + } + + TInt index( KErrNone ); + RArray delIds; + CleanupClosePushL( delIds ); + + TRACE( Print( _L("[FILL MNGR]\t iAllItemCount = %d"), iAllItemCount ) ); + TRACE( Print( _L("[FILL MNGR]\t iFileIds.Count() = %d"), + iFileIds.Count() ) ); + TRACE( Print( _L("[FILL MNGR]\t iNewItemCount = %d"), + iNewItemCount ) ); + // Let's mark to be remove extra files + if( iRuleArray.Count() > 0 ) + { + TRACE( Print( _L("[FILL MNGR]\t fill rule array is not empty!"))); + if( iRuleArray[0]->LimitType() == EMbits ) + { + TRACE( Print( _L("[FILL MNGR]\t fill rule\ + Limit Type is EMbits!") ) ); + + // KMega=1024*1024 + // The size of files to be filled should be small than + // the amount value set by user. + // When realSize be 0 , realCount should be 0 also. + // iAllItemCount > iNewItemCount : sure that extra file be delete + while( ( (( iRuleArray[0]->Amount()*KMega ) < realSize ) && + ( realCount>0 )) || + iAllItemCount > iNewItemCount ) + { + // handle the fill file's count and size. + ProcessFileSizeAndCount( delIds, index, realCount, realSize); + index++; + iAllItemCount--; + } + } + else + { + // when limit tyep are EUnlimited and EPieces + // do not need to limit the size of the file that to be filled. + while( iAllItemCount > iNewItemCount ) + { + // handle the fill file's count and size. + ProcessFileSizeAndCount( delIds, index, realCount, realSize ); + index++; + iAllItemCount--; + } + } + } + else + { + // if the fill rule array is empty ,just show the information. + TRACE( Print( _L("[FILL MNGR]\t fill rule array is empty!"))); + } + // Let's remove items which had ECmToBeFilled or ECmToShrinked status + if( delIds.Count() > KErrNone ) + { + index = KErrNone; + while( delIds.Count() != KErrNone ) + { + ruleSize = ruleSize - iItems[delIds[0] - index]->Size(); + delete iItems[delIds[0] - index]; + iItems.Remove( delIds[0] - index ); + delIds.Remove(0); + index++; + } + } + + CleanupStack::PopAndDestroy( &delIds); + + if( iRuleArray.Count() > 0 ) + { + TRAP( err, iDBManager->SetFillListRealCountAndSizeL( + iRuleArray[0]->ListId(), realCount, ruleSize ) ); + iUpdateItems.Reset(); + for( TInt j = 0; j < iItems.Count(); j++ ) + { + iUpdateItems.Append( iItems[j] ); + } + } + + + TRACE(Print(_L("FILL RULE INFORMATION UPDATE err = %d"), err )); + if ( iRuleArray.Count() > 0 ) + { + iRuleArray.Remove(0); + iRuleArray.Compress(); + } + + TRACE(Print(_L("****** FILL RULE TOTAL SIZE ******"))); + TRACE(Print(_L("FILL RULE SIZE = %ld ( Bytes )"), ruleSize )); + TRACE(Print(_L("****** FILL RULE TOTAL SIZE ******"))); + + /** Spliting long task into shorter ones */ + CompleteRequest( ENextFillRule ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::ProcessFileSizeAndCount +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::ProcessFileSizeAndCount( + RArray& aDelIds, TInt aIndex, + TInt64& aRealCount, + TInt64& aRealSize ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + ProcessFileSizeAndCount()")); + + TRACE( Print( _L(" realCount = %ld, aDelIds's count =%d") , aRealCount, + aDelIds.Count() )); + TRACE( Print( _L(" realSize = %ld ( Bytes )") , aRealSize )); + + // Should this status be set if priority is higher than duplicates + // priority + if( iItems[iFileIds[aIndex]]->Status() == ECmFilled ) + { + iItems[iFileIds[aIndex]]->SetStatus( ECmToBeRemoved ); + aRealCount--; + for( TInt i = 0; i < iItems.Count(); i++ ) + { + if( iItems[i]->RefId() == iItems[iFileIds[aIndex]]->DbId() ) + { + // Set also reference ids to status to be removed + iItems[i]->SetStatus( ECmToBeRemoved ); + } + } + } + else if( iItems[iFileIds[aIndex]]->Status() == ECmToBeFilled || + iItems[iFileIds[aIndex]]->Status() == ECmToBeShrinked ) + { + aRealSize -= iItems[iFileIds[aIndex]]->Size(); + aDelIds.InsertInOrder( iFileIds[aIndex] ); + aRealCount--; + } + else // ECmLocalCopy + { + TRACE(Print(_L("[FILL MNGR]\t No effect on size"))); + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::LoadAllFillItemsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::LoadAllFillItemsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::LoadAllFillItemsL()")); + + iItems.ResetAndDestroy(); + iItems.Close(); + iDBManager->PrepareQueryCmdL( EAllFillFilesQuery ); + TInt err = iDBManager->QueryAllFillFilesL(iItems); + TRACE( Print( _L("[FILL MNGR]\t QueryAllFillFilesL err = %d"), err )); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DefineAndSetDlnaProfileIdFiltersL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DefineAndSetDlnaProfileIdFiltersL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + DefineAndSetDlnaProfileIdFiltersL()")); + + CDesC8Array* array = + &UPnPDlnaUtility::GetSupportedProfilesL( UPnPDlnaUtility::EDMPMode ); + CleanupStack::PushL( array ); + TInt okProfile( EFalse ); + iFilteredProfiles.Reset(); + for( TInt i = 0 ; i < iPropertys.Count(); i++ ) + { + for( TInt j = 0; j < array->Count(); j++ ) + { + if( KErrNotFound != + iPropertys[i]->Name().Match( array->MdcaPoint(j) ) ) + { + // Profile is supported + okProfile = ETrue; + // profile is supported, end loop + j = array->Count(); + } + } + if( !okProfile ) + { + iFilteredProfiles.InsertInSignedKeyOrder( iPropertys[i]->Id() ); + } + okProfile = EFalse; + } + iPropertys.ResetAndDestroy(); + CleanupStack::PopAndDestroy( array ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CompleteRequest +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::CompleteRequest( + TCmFmFillRuleProcessing aStatus ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CompleteRequest()")); + + __ASSERT_DEBUG(!IsActive(),\ + User::Panic( KCmFmFillManager, KErrInUse )); + SetActive(); + TRequestStatus* pStatus = &iStatus; + User::RequestComplete( pStatus, aStatus ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::StartObserverL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::StartObserverL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::StartObserverL()")); + + if( iAo ) + { + delete iAo; + iAo = NULL; + } + iAo = CCmFmAo::NewL( *this ); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CreateWrapperL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::CreateWrapperL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CreateWrapperL()")); + + DeleteWrapper(); + iWrapper = CCmSqlMainFactory::NewCmSqlMainL( iFs ); +#ifndef __SERIES60_31__ + iWrapper->SetDlnaProfileFilters( iFilteredProfiles ); +#endif + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DeleteWrapper +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DeleteWrapper() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DeleteWrapper()")); + + if( iWrapper ) + { + iWrapper->Close(); + iWrapper = NULL; + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::CheckFillListsL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::CheckFillListsL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::CheckFillListsL()")); + + delete iContainer; + iContainer = NULL; + iContainer = LoadAllFillRulesL(); + iRuleArray.Reset(); + for( TInt j = (iContainer->FillRuleCount() - 1 ) ; j >= 0; + j-- ) + { + if( ECmRandom == iContainer->FillRule(j)->Method() || + ECmRandomAlbum == iContainer->FillRule(j)->Method() || + ECmRandomTrack == iContainer->FillRule(j)->Method() ) + { + TInt count( KErrNone ); + iDBManager->GetFillFileCount( + iContainer->FillRule(j)->Name(), + ECmToBeFilled|ECmToBeShrinked|ECmFilled|ECmLocalCopy, + count ); + if( KErrNone < count ) + { + // If rule is random rule which is already processed + // do not process rule automatically + LOG(_L("[FILL MNGR]\t Random rule already processed")); + iContainer->DeleteFillRule( j ); + } + else + { + LOG(_L("[FILL MNGR]\t Random rule is not processed")); + // Don't remove rule + iRuleArray.Append( iContainer->FillRule( j ) ); + } + } + else + { + LOG(_L("[FILL MNGR]\t Rule is not random rule")); + iRuleArray.Append( iContainer->FillRule( j ) ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DeleteHashCodesL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DeleteHashCodesL() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DeleteHashCodesL()")); + + for( TInt i = 0; i < iMetadataServersToBeDeleted.Count(); i++ ) + { + iDBManager->DeleteHashValuesL( iMetadataServersToBeDeleted[i], 0 ); + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::RunL +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::RunL() + { + TRACE(Print(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::RunL\ + status = %d"), iStatus.Int() )); + switch( iStatus.Int() ) + { + case EPreProcessingStarted: + { + CheckFillListsL(); + CompleteRequest( EFillRulesLoaded ); + break; + } + case EQueryFailed: + { + // Error condition what about now... + TRACE(Print(_L("[FILL MNGR]\t EQueryFailed"))); + if( KErrNone < iRuleArray.Count() ) + { + iRuleArray.Remove(0); + iRuleArray.Compress(); + } + TRACE(Print(_L("[FILL MNGR]\t Jump to next rule"))); + CompleteRequest( ENextFillRule ); + break; + } + case EQueryCompleted: + { + // Select needed amount of Fill rules metadata objects + if( KErrNone < iRuleArray.Count() ) + { + SelectFillListFiles( iFileIds, iRuleArray[0]->ListId() ); + iAllItemCount = iFileIds.Count(); + TRACE(Print(_L("[FILL MNGR]\t Already on the list = %d"), + iAllItemCount )); + CompleteRequest( EProcessDuplicates ); + } + else + { + ResetData(); + DeleteWrapper(); + iObserver->FillRuleProcessingStatus(ENoObjectsSelected); + } + break; + } + case ENextFillRule: + { + // Start processing next fill rule + if( KErrNone < iRuleArray.Count() ) + { + LoadMetadataL(iRuleArray[0]); + } + else + { + TRACE(Print(_L("[FILL MNGR]\t Rule array empty"))); + UpdateFillItems(); + ResetData(); + DeleteWrapper(); +#ifdef _DEBUG + TInt alloc; + TInt cells = User::Heap().AllocSize( alloc ); + TInt size = User::Heap().Size(); + TRACE(Print(_L("[FILL MNGR]\t preprocess end heap \ + allocsize %d, size %d, cells %d"), alloc, size, cells )); +#endif + iObserver->FillRuleProcessingStatus(EProcessingReady); + } + break; + } + case EFillRulesLoaded: + { + LoadAllFillItemsL(); + CompleteRequest( EFillFilesLoaded ); + break; + } + case EFillFilesLoaded: + { + if( KErrNone < iRuleArray.Count() ) + { + LoadMetadataL( iRuleArray[0] ); + } + else + { + TRACE(Print(_L("[FILL MNGR]\t Rule array empty"))); + TRAP_IGNORE( CalculateAvgTransferTimeL() ); + SendAvgTransferTime(); + ResetData(); + DeleteWrapper(); + iObserver->FillRuleProcessingStatus(ENoRulesSelected); + } + break; + } + case EProcessDuplicates: + { + ProcessDuplicates(); + break; + } + case EProcessReferenceValues: + { + ProcessReferenceValuesL(); + break; + } + case EProcessStatusValues: + { + ProcessFileStatusValuesL() ; + break; + } + case ERandomizingStarted: + { + if( KErrNone < iRuleArray.Count() ) + { + LoadMetadataL( iRuleArray[0] ); + } + else + { + TRACE(Print(_L("[FILL MNGR]\t Rule array empty"))); + ResetData(); + DeleteWrapper(); + iObserver->FillRuleProcessingStatus(ENoRulesSelected); + } + break; + } + case EColumnDataReady: + { + DeleteWrapper(); + iObserver->FillRuleProcessingStatus(EColumnDataReady); + break; + } + case EUpdatePriorities: + { + DoUpdatePrioritiesL(); + break; + } + case EMetadataDeleted: + { + iObserver->FillRuleProcessingStatus( EMetadataDeleted ); + break; + } + default: + { + LOG(_L("[FILL MNGR]\t Fill rule processing RunL default")); + User::Invariant(); + break; + } + } + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::RunError +// --------------------------------------------------------------------------- +// +#ifdef _DEBUG +TInt CCmFmFillRuleFilledDataMngr::RunError( TInt aError ) +#else +TInt CCmFmFillRuleFilledDataMngr::RunError( TInt /*aError*/ ) +#endif + { + TRACE(Print(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::\ + RunError = %d"), aError )); + + iObserver->FillRuleProcessingStatus( EProcessingFailed ); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DoCancel +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DoCancel() + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DoCancel()")); + } + +// --------------------------------------------------------------------------- +// CCmFmFillRuleFilledDataMngr::DoDeleteProcess +// --------------------------------------------------------------------------- +// +void CCmFmFillRuleFilledDataMngr::DoDeleteProcess( TInt aIndex ) + { + LOG(_L("[FILL MNGR]\t CCmFmFillRuleFilledDataMngr::DoDeleteProcess()")); + TBool delNew( ETrue ); + + //delete duplicated fill item + delete iItems[aIndex]; + iItems.Remove( aIndex ); + + //adjust iOldIds, and judge the item new item or old item + for( TInt i = 0; i < iOldIds.Count(); i++ ) + { + if( iOldIds[i] > aIndex ) + { + iOldIds[i] = iOldIds[i] - 1; + } + else if( iOldIds[i] == aIndex ) + { + delNew = EFalse; + iOldIds.Remove(i); + i--; + } + } + + //adjust iFileIds + for( TInt i = 0; i < iFileIds.Count(); i++ ) + { + if( iFileIds[i] > aIndex ) + { + iFileIds[i] = iFileIds[i] - 1; + } + else if( iFileIds[i] == aIndex ) + { + iFileIds.Remove(i); + i--; + } + } + + //count update + iAllItemCount--; + if( delNew ) + { + iNewItemCount--; + } + } + + +// End of file