diff -r 6369bfd1b60d -r 08b5eae9f9ff homesync/contentmanager/cmserver/cmfillmanager/src/cmfmfillrulefilleddatamngr.cpp --- a/homesync/contentmanager/cmserver/cmfillmanager/src/cmfmfillrulefilleddatamngr.cpp Mon Nov 01 13:44:24 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1686 +0,0 @@ -/* -* 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: ou1s60rt#18 % << 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.AppendL( 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.AppendL( 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.AppendL( 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.InsertInOrderL( 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.InsertInOrderL( 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.InsertInOrderL( 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.AppendL( 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.InsertInOrderL( 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.AppendL( iContainer->FillRule( j ) ); - } - } - else - { - LOG(_L("[FILL MNGR]\t Rule is not random rule")); - iRuleArray.AppendL( 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