--- 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 <e32property.h>
-#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<CCmFillListItem>& 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<CCmFillListItem>& 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<CCmFillListItem>& 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<CCmMediaServerFull> 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<CCmFillListItem>& 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<CCmFillListItem>& 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<CCmMediaServerFull> 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<HBufC8> 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<HBufC8> 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<TInt> 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<TInt>& 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<TInt> 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<TInt>& 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