--- a/homesync/contentmanager/cmserver/cmfillmanager/src/cmfmmain.cpp Mon Nov 01 13:44:24 2010 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1774 +0,0 @@
-/*
-* Copyright (c) 2008 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: Main class in the Fill manager component
-*
-*/
-
-
-#include <e32property.h>
-#include <e32std.h>
-#include <f32file.h>
-#include <badesca.h>
-#include "upnpavdevice.h"
-#include "upnpavcontroller.h"
-#include "upnpavdevicelist.h"
-#include "upnpitem.h"
-#include "upnpcontainer.h"
-#include <pathinfo.h>
-#include <utf.h>
-#include "cmserviceobserver.h"
-#include "cmfmdownloadproxy.h"
-#include "cmfmupnpmngr.h"
-#include "cmfmfilldrivemngr.h"
-#include "cmfmduplicatedetector.h"
-#include "cmdriveinfo.h"
-#include "cmfmfillrulefilleddatamngr.h"
-#include "cmfmmpxnotifier.h"
-#include "cmfmglxnotifier.h"
-#include "cmfmcommon.h"
-#include "cmdmmain.h"
-#include "cmmmmain.h"
-#include "cmfilllistitem.h"
-#include "cmsqlpropertyitem.h"
-#include "cmsqlpropertycontainer.h"
-#include "cmfmmain.h"
-#include "msdebug.h"
-
-const TUint8 KExtensionLength = 4;
-const TInt KCmFmOneFile = 1;
-const TInt KCmFmLengthOfRoot = 3;
-const TInt KCmFmOneSecond = 1000000;
-const TInt KArrayGranularity = 10;
-const TInt KExtraSpace = 5; // space reserved for backslashes etc.
-const TInt KDefaultCalculateSize = 100;
-
-_LIT16( KCmKorp, "<" );
-_LIT16( KCmProk, ">" );
-_LIT16( KCmQuotation, "\"" );
-_LIT16( KCmDoubleBackSlash, "\\" );
-_LIT16( KCmSlash, "/" );
-_LIT16( KCmStar, "*" );
-_LIT16( KCmPipe, "|" );
-_LIT16( KCmColon, ":");
-_LIT16( KCmQuestionMark, "?" );
-_LIT16( KCmUnderScore, "_" );
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::NewL
-// ---------------------------------------------------------------------------
-//
-CCmFmMain* CCmFmMain::NewL( MCmServiceObserver* aObserver,
- CMdESession& aSession, CCmDmMain* aDBManager,
- CCmMmMain* aMemManager )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::NewL() start"));
- CCmFmMain* self = CCmFmMain::NewLC( aObserver, aSession,
- aDBManager, aMemManager );
- CleanupStack::Pop( self );
- LOG(_L("[FILL MNGR]\t CCmFmMain::NewL() end"));
- return self;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::NewLC
-// ---------------------------------------------------------------------------
-//
-CCmFmMain* CCmFmMain::NewLC( MCmServiceObserver* aObserver,
- CMdESession& aSession, CCmDmMain* aDBManager,
- CCmMmMain* aMemManager )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::NewLC() start"));
- CCmFmMain* self = new ( ELeave ) CCmFmMain( aObserver,
- aMemManager, aDBManager );
- CleanupStack::PushL( self );
- self->ConstructL( aSession, aDBManager );
- LOG(_L("[FILL MNGR]\t CCmFmMain::NewLC() end"));
- return self;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::~CCmFmMain
-// ---------------------------------------------------------------------------
-//
-CCmFmMain::~CCmFmMain()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::~CCmFmMain() start"));
- if( IsActive() )
- {
- Cancel();
- }
- iFile.Close();
- iFsSession.Close();
- delete iCmFmFillDriveMngr;
- delete iCmFmUpnpMngr;
-
- if( iDevices )
- {
- iDevices->ResetAndDestroy();
- delete iDevices;
- iDevices = NULL;
- }
-
- delete iCmFmFillRuleFilledDataMngr;
- delete iCmFmDownloadProxy;
- delete iCmFmDuplicateDetector;
- delete iCmFmGlxNotifier;
- delete iCmFmMpxNotifier;
-
- ResetDeleteQueue();
- ResetItems();
- iFullPath.Zero();
- iDrives.ResetAndDestroy();
- iDrives.Close();
- LOG(_L("[FILL MNGR]\t CCmFmMain::~CCmFmMain() end"));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::CCmFmMain
-// ---------------------------------------------------------------------------
-//
-CCmFmMain::CCmFmMain( MCmServiceObserver* aObserver,
- CCmMmMain* aMemManager, CCmDmMain* aDBManager )
- : CActive( EPriorityStandard ), iObserver( aObserver ),
- iMemManager( aMemManager ), iDbManager( aDBManager )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::CCmFmMain()"));
-
- CActiveScheduler::Add( this );
- iProgressInfo.iService = ECmServiceNone;
- iProgressInfo.iProcessedItems = 0;
- iProgressInfo.iItemsToTransferPerService = 0;
- iProgressInfo.iTotalItems = 0;
- iService = ECmServiceFill;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ConstructL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ConstructL( CMdESession& aSession, CCmDmMain* aDBManager )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ConstructL() start"));
-
- User::LeaveIfError( iFsSession.Connect() );
- User::LeaveIfError( iFsSession.ShareProtected() );
- iCmFmFillDriveMngr = CCmFmFillDriveMngr::NewL( iFsSession, iDrives );
- iCmFmUpnpMngr = CCmFmUpnpMngr::NewL( this );
- iCmFmFillRuleFilledDataMngr =
- CCmFmFillRuleFilledDataMngr::NewL( this, aDBManager, iItems );
- iCmFmDownloadProxy = CCmFmDownloadProxy::NewL( );
- iCmFmDuplicateDetector = CCmFmDuplicateDetector::NewL( *this, aSession );
- iCmFmGlxNotifier = CCmFmGlxNotifier::NewL( iFsSession );
- iCmFmMpxNotifier = CCmFmMpxNotifier::NewL( );
- LOG(_L("[FILL MNGR]\t CCmFmMain::ConstructL() end"));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::StartFillL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::StartFillL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::StartFillL()"));
-
- iDbManager->GetProgressInfo( iProgressInfo.iProcessedItems,
- iProgressInfo.iTotalItems );
- iProgressInfo.iItemsToTransferPerService =
- iDbManager->FillFileCount( ECmToBeShrinked|ECmToBeFilled );
- iService = ECmServiceFill;
- iProgressInfo.iService = ECmServiceFill;
- iTempIndex = 0;
- SendProgressInfo( KErrNone );
- LoadDrivesL();
- CompleteRequest( ECmFmMMCCheckStarted );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::CancelOperation
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::CancelOperation()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::CancelOperation()"));
-
- // Destroy all active objects
- iCmFmUpnpMngr->CancelOperation();
- iCmFmFillRuleFilledDataMngr->CancelOperation();
- iCmFmDownloadProxy->CancelOperation();
- LOG(_L("[FILL MNGR]\t Filling => Update items to database"));
- if( KErrNone < iItems.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateFillItems( ETrue );
- }
- if( KErrNone < iToBeDeleted.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateToBeDeleted( iToBeDeleted );
- }
- UpdateDrives();
-
- // File fetching was ongoing => have to notify gallery
- // about deleted file
- if( iFetchingFile && iIndex < iItems.Count() )
- {
- iFsSession.Delete( iFullPath );
- TRAP_IGNORE( iCmFmGlxNotifier->NotifyGalleryL( iFullPath ) );
- }
-
- // Update UI information
- TRAPD( err, iCmFmFillRuleFilledDataMngr->CalculateAvgTransferTimeL() );
- if( err )
- {
- TRACE(Print(_L("[FILL MNGR]\t CancelOperation error = %d"), err ));
- }
-
- iCmFmFillRuleFilledDataMngr->SendAvgTransferTime();
- iCmFmFillRuleFilledDataMngr->ResetData();
- Cancel();
- iObserver->ServiceExecuted( iService, KErrCancel );
- if( iProgressInfo.iService != ECmServiceNone )
- {
- // Service finished. Reset progress info.
- iProgressInfo.iService = ECmServiceNone;
- SendProgressInfo( KErrNone );
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::PreProcessListsL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::PreProcessListsL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::PreProcessListsL()"));
-
- if( KErrNone == iDbManager->FillFileCount(
- ECmToBeShrinked|ECmToBeFilled|ECmToBeRemoved|ECmFilled ) )
- {
- // Set used fill space to zero
- InitializeDriveQuotasL();
- }
- iService = ECmServicePreProcessingFill;
-
- TRAPD( err, iCmFmFillRuleFilledDataMngr->LoadProfileIdsL() );
-
- if( err )
- {
- iObserver->ServiceExecuted( iService, KErrNone );
- }
-
- SetMmcQuotaL();
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::PreProcessListL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::PreProcessListL( const TDesC8& aFillListName )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::PreProcessListL()"));
-
- if( KErrNone == iDbManager->FillFileCount(
- ECmToBeShrinked|ECmToBeFilled|ECmToBeRemoved|ECmFilled ) )
- {
- // Set used fill space to zero
- InitializeDriveQuotasL();
- }
- iService = ECmServicePreProcessingFilllist;
- TRAPD( err,
- iCmFmFillRuleFilledDataMngr->PreProcessListL( aFillListName) );
- if( err )
- {
- TRACE(Print(_L("[FILL MNGR]\t PreProcessListL err = %d"), err ));
- iObserver->ServiceExecuted( iService, KErrNone );
- }
-
- SetMmcQuotaL();
-
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::GetColItemsL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::GetColItemsL( TCmMetadataField /*aType*/,
- TCmMediaType /*aMedia*/, CDesCArray& /*aArray*/ )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::GetColItemsL()"));
-
- iService = ECmServiceGetFillFields;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::GetMetadataItemsL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::GetMetadataItemsL(
- CCmSqlPropertyCollector& aPropertys )
-
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::GetMetadataItemsL()"));
-
- iService = ECmServiceGetFillFields;
- iCmFmFillRuleFilledDataMngr->GetMetadataItemsL( aPropertys );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::GetColItemsL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::GetColItemsL( TCmMetadataField aType,
- TCmMediaType aMedia, CCmSqlPropertyContainer& aPropertys )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::GetColItemsL()"));
-
- iService = ECmServiceGetFillFields;
- iCmFmFillRuleFilledDataMngr->GetColItemsL( aType, aMedia, aPropertys );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::SetAvController
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::SetAvController( MUPnPAVController* aAVController )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::SetAvController()"));
-
- iAvController = aAVController;
- iCmFmUpnpMngr->SetAvController( aAVController );
- iCmFmDownloadProxy->CancelOperation( );
- ResetItemInfo();
- iDrives.ResetAndDestroy();
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::UpdatePriorities
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::UpdatePriorities()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::UpdatePriorities()"));
-
- iCmFmFillRuleFilledDataMngr->UpdatePriorities();
- iService = ECmServiceUpdateFillLists;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::UpdateRefIds
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::UpdateRefIds()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::UpdateRefIds()"));
-
- TRAPD( err, iCmFmFillRuleFilledDataMngr->DoUpdateReferenceIdsL() );
- if( err )
- {
- TRACE(Print(_L("[FILL MNGR]\t UpdateRefIds err = %d"), err ));
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::DeleteMetadataL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::DeleteMetadataL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::DeleteMetadataL()"));
-
- iCmFmFillRuleFilledDataMngr->DeleteMetadataL();
- iService = ECmServiceDeleteMetadata;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::SetMmcQuotaL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::SetMmcQuotaL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::SetMmcQuotaL()"));
-
- LoadDrivesL();
- TInt64 quota( KErrNone );
- for( TInt i = 0 ; i < iDrives.Count(); i++ )
- {
- if( quota < iDrives[i]->DriveQuota() )
- {
- quota = iDrives[i]->DriveQuota();
- }
- }
- iDrives.ResetAndDestroy();
- TRACE(Print(_L("[FILL MNGR]\t Max fill list size in bytes = %ld"),
- quota ));
- iCmFmFillRuleFilledDataMngr->SetMemoryCardQuota( quota );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::FillRuleProcessingStatus
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::FillRuleProcessingStatus( TCmFmFillRuleProcessing aStatus )
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::\
- FillRuleProcessingStatus status = %d"), (TInt)aStatus ));
-
- switch( aStatus )
- {
- case EProcessingReady:
- {
- iObserver->ServiceExecuted( iService,
- KErrNone );
- break;
- }
- case ENoRulesSelected: // fall through
- case ENoObjectsSelected: // fall through
- case EColumnDataReady: // fall through
- case EDoUpdatePriorities: // fall through
- case EMetadataDeleted:
- {
- // Finish fill operation
- iObserver->ServiceExecuted( iService, KErrNone );
- break;
- }
- case EProcessingCanceled:
- {
- break;
- }
- case EProcessingFailed:
- {
- iObserver->ServiceExecuted( iService,
- KErrUnknown );
- break;
- }
- default:
- {
- LOG(_L("[FILL MNGR]\t Wrong status in Fill rule processing"));
- User::Invariant();
- break;
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::TransferStatus
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::TransferStatus( TCmFmTransferStatus aStatus, TInt aSessionId,
- TInt aInternalItemId, TInt aError, TInt64 aFSize )
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::TransferStatus status = %d \
- error = %d"), (TInt)aStatus, (TInt)aError ));
-
- TInt err( KErrNone );
- switch( aStatus )
- {
- case ECmFmFileFetchStarted:
- {
- if( !aError )
- {
- TRACE(Print(_L("[FILL MNGR]\t File download started!")));
- iFetchingFile = ETrue;
- }
- else if( KErrDisconnected == aError )
- {
- TransferStatus( ECmFmFileFetched, aSessionId, 0,
- aError, 0 );
- }
- else
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- break;
- }
- case ECmFmFileFetched:
- {
- iFetchingFile = EFalse;
- iFile.Close();
- if( !aError )
- {
- TTime fetchFinished;
- fetchFinished.HomeTime();
- TTimeIntervalMicroSeconds usecsFrom =
- fetchFinished.MicroSecondsFrom(iFileFetchStart);
- TRACE(Print(_L("[FILL MNGR]\t File Fetch \
- took = %ld microseconds"), usecsFrom.Int64() ));
-
- // Update Fill quota
- TInt64 fillSpace( KErrNone );
- fillSpace = iDrives[iDriveIndex]->UsedDriveQuota() +
- ( aFSize * KKilo );
- UpdateDriveQuota( iDriveNumber, fillSpace );
-
- TInt64 timeinsecs((TInt64)(usecsFrom.Int64()/KCmFmOneSecond));
- // Update transfer history information
- iCmFmFillRuleFilledDataMngr->UpdateTransferHistoryData(
- timeinsecs, aFSize,
- iItems[iIndex]->DevId() );
-
- // Update progress info
- SendProgressInfo( KCmFmOneFile );
-
- if( iItems[iIndex]->Status() == ECmToBeShrinked )
- {
- // Let's update file status
- TRAP( err, SetStatusL( aInternalItemId ) );
- TRACE(Print(_L("[FILL MNGR]\t SetStatusL err = %d"), err));
- CompleteRequest( ECmFmShrinkImage );
- }
- else
- {
- TRAP( err, ReplaceFileL( iItems[iIndex]->Path() ) );
- TRACE(Print(_L("[FILL MNGR]\t ReplaceFileL err = %d"),
- err));
- TRAP_IGNORE( iCmFmGlxNotifier->NotifyGalleryL( iFullPath ) );
- if( iItems[iIndex]->MediaType() == ECmAudio )
- {
- TRAP( err, iCmFmMpxNotifier->NotifyMpxL(
- iFullPath, iCmFmUpnpMngr->UpnpItem() ) );
- TRACE(Print(_L("[FILL MNGR]\t NotifyMpxL err = %d"),
- err));
- }
- else
- {
- TRACE(Print(_L("[FILL MNGR]\t Image or video file")));
- }
- // Let's update file status to filled
- TRAP( err, SetStatusL( aInternalItemId ) );
- TRACE(Print(_L("[FILL MNGR]\t SetStatusL err = %d"), err));
- // Jump to next file => Update item index
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else if( KErrDisconnected == aError )
- {
- // Close used session: wlan connection lost or
- // used media server disappeared
- if( iCmFmDownloadProxy->CloseDownloadSession( aSessionId ) )
- {
- // Continue if some sessions still available
- if( !IsActive() )
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else
- {
- // Update item information into db
- if( KErrNone < iItems.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateFillItems();
- }
- if( KErrNone < iToBeDeleted.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateToBeDeleted(
- iToBeDeleted );
- }
- UpdateDrives();
- // Finish filling if connection to all sessions lost
- iObserver->ServiceExecuted( iService, KErrGeneral );
- }
- }
- else
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- break;
- }
- default:
- {
- LOG(_L("[FILL MNGR]\t Wrong status in transfer"));
- User::Invariant();
- break;
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::URICheckResult
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::URICheckResult( TCmFmUriCheckResult aStatus,
- const CUpnpItem* aItem, const CUpnpElement* aRes )
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::URICheckResult status = %d"),
- (TInt)aStatus ));
-
- switch( aStatus )
- {
- case ECanceled:
- {
- // Finish operation
- iIndex = iItems.Count();
- CompleteRequest( ECmFmCheckItem );
- break;
- }
- case ENoUriAvailable:
- {
- // No uri available => Jump to next item
- ProceedWithNextItem( ECmFmCheckItem );
- break;
- }
- case EUriChecked:
- {
- TRAPD( err, SetUriL( ) );
- TRACE(Print(_L("[FILL MNGR]\t SetUriL err = %d"), err ));
- TInt error( KErrNone );
- TRAP( err, error = ParseFullPathL() );
- TRACE(Print(_L("[FILL MNGR]\t ParseFullPathL err=%d"), err ));
- if( KErrNone == error &&
- iItems[iIndex]->Uri().Length() != KErrNone )
- {
- iFullPath.Zero();
- TRAP( err, PrivatePathL( ) );
- TRACE(Print(_L("[FILL MNGR]\t PrivatePathL err=%d"), err ));
- error = CreateRFile( iFullPath );
- TRACE(Print(_L("[FILL MNGR]\t CreateRFile error = %d"),
- error ));
- if( !error )
- {
- iFileFetchStart.HomeTime();
- TRAP( error, iCmFmDownloadProxy->FetchFileL( this,
- iAvController, iDevices, *aRes, *aItem,
- iFile, CheckServerIndex( *iUuid, *iDevices ),
- iItems[iIndex]->DbId() ) );
- TRACE(Print(_L("[FILL MNGR]\t FetchFileL error = %d"),
- error));
- }
- if( error )
- {
- TRACE(Print(_L("[FILL MNGR]\t Error = %d"), error ));
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- break;
- }
- default:
- {
- LOG(_L("[FILL MNGR]\t Wrong URI check value"));
- User::Invariant();
- break;
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::Duplicate
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::DuplicateL( const TBool aDuplicate )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::Duplicate()"));
-
- if( !aDuplicate )
- {
- // Not duplicate
- CompleteRequest( ECmFmStartUriCheck );
- }
- else
- {
- TInt index( iIndex );
- // Duplicate => skip item and check next one
- ProceedWithNextItem( ECmFmCheckItem );
-
- if ( index < iItems.Count() )
- {
- // Update status of duplicate item to filled
- iItems[index]->SetStatus( ECmFilled );
- RPointerArray<CCmBaseListItem> items;
- CleanupClosePushL( items );
- items.AppendL( iItems[index] );
- iDbManager->UpdateStatusValues( items );
- items.Reset();
- CleanupStack::PopAndDestroy( &items );
-
- // Update transfer info
- TInt count( KErrNone );
- TInt time( KErrNone );
- iDbManager->GetTransferInfo( ECmServiceFill, count, time );
- iProgressInfo.iItemsToTransferPerService =
- iDbManager->FillFileCount( ECmToBeShrinked|ECmToBeFilled );
- iDbManager->UpdateTransferInfo( ECmServiceFill,
- iProgressInfo.iItemsToTransferPerService, time );
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::DeleteCompleteL
-// ---------------------------------------------------------------------------
-//
-#ifdef _DEBUG
-void CCmFmMain::DeleteCompleteL( TInt aErr )
-#else
-void CCmFmMain::DeleteCompleteL( TInt /*aErr*/ )
-#endif
- {
- TRACE(Print(_L("[FILL MNGR]\t DeleteCompleteL err = %d"), aErr ));
- //this function is called back by CmMmMain
- //after all array is be deleted or cancel
- for( TInt i = iToBeDeleted.Count() - 1; i >= 0; i-- )
- {
- if ( KErrNone == iToBeDeleted[i]->RefId() )
- {
- delete iToBeDeleted[i];
- iToBeDeleted.Remove( i );
- }
- }
- iToBeDeleted.Compress();
- CompleteRequest( ECmFmCheckItem );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ShrinkCompleteL
-// ---------------------------------------------------------------------------
-//
-#ifdef _DEBUG
-void CCmFmMain::ShrinkCompleteL( TInt aErr )
-#else
-void CCmFmMain::ShrinkCompleteL( TInt /*aErr*/ )
-#endif
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::\
- ShrinkCompleteL err = %d"), aErr ));
-
- ReplaceFileL( iItems[iIndex]->Path() );
- iCmFmGlxNotifier->NotifyGalleryL( iFullPath );
- ProceedWithNextItem( ECmFmCheckItem );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::RunL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::RunL()
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::\
- RunL status = %d"), iStatus.Int() ));
-
- switch( iStatus.Int() )
- {
- case ECmFmMMCCheckStarted:
- {
- // Update updated drive array into database
- UpdateDrives();
- // Check first Drive Id
- CompleteRequest( iCmFmFillDriveMngr->CheckDriveId() );
- break;
- }
- case ECmFmWrongMMC:
- {
- // Error Wrong MMC
- iObserver->ServiceExecuted( iService, KErrNone );
- break;
- }
- case ECmFmMMCOk:
- {
- HandleIfMmcOkL();
- break;
- }
- case ECmFmMMCCheckFailed:
- {
- // Error MMC check failed
- iObserver->ServiceExecuted( iService, KErrNone );
- break;
- }
- case ECmFmStartUriCheck:
- {
- if( iIndex < iItems.Count() &&
- ECmFilled != iItems[iIndex]->Status() &&
- ECmLocalCopy != iItems[iIndex]->Status() &&
- KErrNone == iItems[iIndex]->RefId() &&
- ECmSelected == iItems[iIndex]->Selected() )
- {
- DoUriCheckL();
- }
- else
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- break;
- }
- case ECmFmBrowseReady:
- {
- TRAP_IGNORE( SetUriL() );
- CompleteRequest( ECmFmUriOK );
- break;
- }
- case ECmFmCheckItem:
- {
- if( iIndex < iItems.Count() )
- {
- TBool checkneed( EFalse );
- if( iIndex < iItems.Count() &&
- ECmFilled != iItems[iIndex]->Status() &&
- ECmLocalCopy != iItems[iIndex]->Status() &&
- KErrNone == iItems[iIndex]->RefId() &&
- ECmSelected == iItems[iIndex]->Selected() )
- {
- TRAPD( err,
- iCmFmDuplicateDetector->CheckItemL( *iItems[iIndex] ) );
- if( !err )
- {
- checkneed = ETrue;
- }
- }
- if( !checkneed )
- {
- // Error occurred => Jump to next item
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else
- {
- StopItemCheck();
- iObserver->ServiceExecuted( iService, KErrNone );
- }
- break;
- }
- case ECmFmDeleteFiles:
- {
- HandleIfDeleteFilesL();
- break;
- }
- case ECmFmShrinkImage:
- {
- ResetDeleteQueue();
- iArray = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );
- iArray->AppendL( iFullPath );
- // Let's ensure that fill manager is set as a observer
- iMemManager->SetObserver( *this );
- iMemManager->ShrinkImagesL( *iArray );
- break;
- }
- default:
- {
- // NOT HERE -> Panic
- LOG(_L("[FILL MNGR]\t RunL default"));
- User::Invariant();
- break;
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::DoCancel
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::DoCancel()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::DoCancel()"));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::RunError
-// ---------------------------------------------------------------------------
-//
-#ifdef _DEBUG
-TInt CCmFmMain::RunError( TInt aError )
-#else // _DEBUG
-TInt CCmFmMain::RunError( TInt /*aError*/ )
-#endif // _DEBUG
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::RunError = %d"), aError ));
-
- iObserver->ServiceExecuted( iService, KErrNone );
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::HandleIfMmcOkL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::HandleIfMmcOkL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::HandleIfMmcOkL()"));
-
- iIndex = KErrNone;
- iCmFmFillRuleFilledDataMngr->GetFillItemsL();
- iCmFmFillRuleFilledDataMngr->GetToBeDeletedL(iToBeDeleted);
- if ( iDevices )
- {
- iDevices->ResetAndDestroy();
- delete iDevices;
- iDevices = NULL;
- }
- TRAPD( err, iCmFmUpnpMngr->GetMediaServersL( iDevices ) );
- TRACE(Print(_L("[FILL MNGR]\t GetMediaServersL err = %d"), err ));
- if( err )
- {
- iObserver->ServiceExecuted( iService, KErrNone );
- }
- else
- {
-#ifdef _DEBUG
- LogServers();
-#endif
- if( !iDevices->Count() )
- {
- TRACE(Print(_L("[FILL MNGR]\t No devices selected")));
- iObserver->ServiceExecuted( iService, KErrNotFound );
- ResetItems();
- }
- else
- {
- // If some of needed servers is available and there is items to
- // be transfered => Start fill
- if( NeededServerAvailableL() &&
- iProgressInfo.iItemsToTransferPerService )
- {
- CompleteRequest( ECmFmDeleteFiles );
- }
- else
- {
- TRACE(Print(_L("[FILL MNGR]\t No needed server available")));
- TRACE(Print(_L("[FILL MNGR]\t Or no items to be transfered.")));
- TInt errorCode( KErrNone );
- if( 0 != iProgressInfo.iItemsToTransferPerService )
- {
- errorCode = KErrNotFound;
- }
- iObserver->ServiceExecuted( iService , errorCode );
- ResetItems();
- }
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::HandleIfDeleteFilesL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::HandleIfDeleteFilesL()
- {
- TRACE(Print(_L("[FILL MNGR]\t CCmFmMain::ECmFmDeleteFiles, iIndex = %d"),
- iIndex ));
- ResetDeleteQueue();
- AddFilesToDeleteQueueL();
- if( KErrNone != iArray->Count() )
- {
- iMemManager->SetObserver( *this );
- iMemManager->DeleteFilesL( *iArray );
- }
- else
- {
- iCmFmDuplicateDetector->ResetArray();
- CompleteRequest( ECmFmCheckItem );
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::CompleteRequest
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::CompleteRequest(
- TCmFmStatus aStatus )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::CompleteRequest()"));
-
- __ASSERT_DEBUG(!IsActive(),\
- User::Panic( KCmFmFillManager, KErrInUse ));
- SetActive();
- TRequestStatus* pStatus = &iStatus;
- User::RequestComplete( pStatus, aStatus );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ProceedWithNextItem
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ProceedWithNextItem( TCmFmStatus aStatus )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ProceedWithNextItem()"));
-
- __ASSERT_DEBUG(!IsActive(),\
- User::Panic( KCmFmFillManager, KErrInUse ));
- iIndex++;
- SetActive();
- TRequestStatus* pStatus = &iStatus;
- User::RequestComplete( pStatus, aStatus );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::DoUriCheckL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::DoUriCheckL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::DoUriCheckL()"));
-
- ResetItemInfo();
- TInt ret( KErrNone );
- if( iIndex < iItems.Count() )
- {
- ret = iCmFmFillRuleFilledDataMngr->GetUuidL( iUuid,
- iItems[iIndex]->DevId() );
- }
- else
- {
- ret = KErrNotFound;
- }
- // Check if file fits to mmc
- iDriveIndex = iCmFmFillDriveMngr->CheckFreeDiscSpace(
- iItems[iIndex]->Size(), iDriveId, iDriveNumber );
- iItems[iIndex]->SetDriveNumber( iDriveNumber );
- iItems[iIndex]->SetDriveId( iDriveId );
- if( ( KErrNone == ret ) &&
- ( KErrNone < iDevices->Count() ) && iDriveNumber != -1 )
- {
- TBool found(EFalse);
- TInt index(0);
- for( TInt i = 0; i < iDevices->Count() && !found &&
- iUuid ; i++ )
- {
- if( KErrNotFound != (((*iDevices)[i]->Uuid()).Match(*iUuid) ) )
- {
- found = ETrue;
- index = i;
- TRACE(Print(_L("[FILL MNGR]\t device found= %d"), index ));
- }
- }
- if( found )
- {
- TRAPD( error, iCmFmUpnpMngr->CheckURIL( (*iDevices)[index],
- *iItems[ iIndex ]) );
- if( error )
- {
- TRACE(Print(_L("[FILL MNGR]\t Uri check failed...")));
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else
- {
- // Jump to next item
- TRACE(Print(_L("[FILL MNGR]\t Device not found")));
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
- else if( KErrNotFound == ret )
- {
- // Jump to next item
- TRACE(Print(_L("[FILL MNGR]\t Media server not in db")));
- ProceedWithNextItem( ECmFmCheckItem );
- }
- else if( iDriveNumber == -1 && KErrNone < iToBeDeleted.Count() )
- {
- // Jump to next item
- TRACE(Print(_L("[FILL MNGR]\t FILE TOO BIG OR NO DRIVES SELECTED")));
- ProceedWithNextItem( ECmFmCheckItem );
- }
- else
- {
- ProceedWithNextItem( ECmFmCheckItem );
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ParseFullPathL
-// ---------------------------------------------------------------------------
-//
-TInt CCmFmMain::ParseFullPathL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ParseFullPathL()"));
-
- iFullPath.Zero();
- TInt ret( KErrNone );
- if( iIndex < iItems.Count() )
- {
- HBufC* temp = ResolveAndAppendRootPathL( iDriveNumber );
- CleanupStack::PushL( temp );
-
- iFullPath.Append( *temp );
-
- CleanupStack::PopAndDestroy( temp );
-
- if( ECmAudio == iItems[iIndex]->MediaType() )
- {
- iFullPath.Append( PathInfo::SoundsPath() );
- }
- else if( ECmVideo == iItems[iIndex]->MediaType() )
- {
- iFullPath.Append( PathInfo::VideosPath() );
- }
- else if( ECmImage == iItems[iIndex]->MediaType() )
- {
- iFullPath.Append( PathInfo::ImagesPath() );
- }
- else
- {
- // Not supported upnp class use OthersPath
- iFullPath.Append( PathInfo::OthersPath() );
- }
- ret = ParseFileNameL();
- }
- else
- {
- ret = KErrNotFound;
- }
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ParseFileNameL
-// ---------------------------------------------------------------------------
-//
-TInt CCmFmMain::ParseFileNameL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ParseFileNameL()"));
-
- TInt index(0);
- TInt ret( KErrNone );
- if( KErrNone != iItems[iIndex]->Uri().Length() )
- {
- const TChar slash( '/' );
- index = iItems[iIndex]->Uri().LocateReverse( slash );
- if( KErrNotFound < index && KErrNone !=
- iItems[iIndex]->PrimaryText().Length() )
- {
- HBufC* data16bitBuf = RemoveIllegalFilenameCharactersL(
- iItems[iIndex]->PrimaryText() );
- TBuf<KExtensionLength>fileExtension;
- fileExtension.Zero();
- TInt conversionError = CnvUtfConverter::
- ConvertToUnicodeFromUtf8(fileExtension,
- iItems[iIndex]->Uri().Mid(
- (iItems[iIndex]->Uri().Length() -
- KExtensionLength), KExtensionLength) );
-
- if( conversionError )
- {
- ret = KErrGeneral;
- }
- else if ( ( iFullPath.Length() +
- data16bitBuf->Length() + fileExtension.Length() ) <
- KMaxFileName )
- {
- iFullPath.Append(*data16bitBuf);
- iFullPath.Append(fileExtension);
- iItems[iIndex]->SetPathL(
- iFullPath.Mid( KCmFmLengthOfRoot ) );
- iItems[iIndex]->SetDriveNumber( iDriveNumber );
- iItems[iIndex]->SetDriveId( iDriveId );
- iFullPath.Zero();
- }
- else
- {
- iFullPath.Append( data16bitBuf->Left(
- KMaxFileName - iFullPath.Length() -
- fileExtension.Length() - KExtraSpace ) );
-
- iFullPath.Append(fileExtension);
- iItems[iIndex]->SetPathL(
- iFullPath.Mid( KCmFmLengthOfRoot ) );
- iItems[iIndex]->SetDriveNumber( iDriveNumber );
- iItems[iIndex]->SetDriveId( iDriveId );
- iFullPath.Zero();
- }
- delete data16bitBuf;
- data16bitBuf = NULL;
- }
- }
- else
- {
- LOG(_L("[FILL MNGR]\t File name parsing, compose failed)"));
- ret = KErrGeneral;
- }
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::SetUriL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::SetUriL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::SetUriL()"));
-
- if( iIndex < iItems.Count() )
- {
- iItems[iIndex]->SetUriL( iCmFmUpnpMngr->Uri() );
- }
- LOG(_L("[FILL MNGR]\t SetUriL end"));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::LogServers
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::LogServers()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::LogServers()"));
-
- for( TInt i = 0; i < iDevices->Count(); i++ )
- {
- TBuf<KMaxName>temp;
- if((*iDevices)[i])
- {
- if( &(*iDevices)[i]->Uuid())
- {
- if( (*iDevices)[i]->Uuid().Length() < KMaxName )
- {
- temp.Copy( (*iDevices)[i]->Uuid() );
- TRACE(Print(_L("[FILL MNGR]\t FOUND DEVICE %d = %S"),
- i+1, &temp ));
- }
- temp.Zero();
- }
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ResetItemInfo
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ResetItemInfo()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ResetItemInfo()"));
-
- if( iUuid )
- {
- delete iUuid;
- iUuid = NULL;
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::SendProgressInfo
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::SendProgressInfo( TInt aProgress )
- {
- if ( iProgressInfo.iTotalItems > iProgressInfo.iProcessedItems )
- {
- iProgressInfo.iProcessedItems += aProgress;
- iProgressInfo.iItemsToTransferPerService -= aProgress;
- TCmProgressInfoPckg progressPckg( iProgressInfo );
- TRACE( Print( _L("[FILL MNGR]\t processed: %d total %d"),
- iProgressInfo.iProcessedItems, iProgressInfo.iTotalItems) );
-
- if ( ( iProgressInfo.iTotalItems <= iProgressInfo.iProcessedItems ) ||
- ( iProgressInfo.iTotalItems > iProgressInfo.iProcessedItems &&
- iProgressInfo.iProcessedItems > 0 &&
- ( iProgressInfo.iProcessedItems - iTempIndex ) >=
- iProgressInfo.iTotalItems / KDefaultCalculateSize )
- )
- {
- iTempIndex = iProgressInfo.iProcessedItems;
- TInt err = RProperty::Set( KCmPropertyCat, KCmProperty,
- progressPckg );
- TRACE( Print( _L("[FILL MNGR]\t RProperty::Set returned %d"),
- err));
- }
- else
- {
- LOG(_L("[FILL MNGR]\t progress small no need to pub&sub"));
- }
- }
-
- else
- {
- iProgressInfo.iProcessedItems += aProgress;
- LOG(_L("[FILL MNGR]\t Bigger than 100%% or not beginning"));
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::SetStatusL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::SetStatusL( const TInt64 aInternalItemId )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::SetStatusL()"));
-
- if( iIndex < iItems.Count() )
- {
- iItems[iIndex]->SetStatus( ECmFilled );
- TUint id(iItems[iIndex]->DbId());
- for( TInt i = 0; i < iItems.Count(); i++ )
- {
- // Set all reference items also filled
- if( aInternalItemId == iItems[i]->RefId() &&
- iItems[i]->Selected() == ECmSelected )
- {
- iItems[i]->SetStatus( ECmFilled );
- iItems[i]->SetPathL( iItems[iIndex]->Path() );
- iItems[i]->SetDriveId( iItems[iIndex]->DriveId() );
- iItems[i]->SetDriveNumber( iItems[iIndex]->DriveNumber() );
- }
- }
- // add to duplicatied detector
- iCmFmDuplicateDetector->AppendToArrayL( *iItems[iIndex] );
- // Update statuses into db
- iDbManager->UpdateFillTransferStatus( ECmFilled, iItems[iIndex] );
- TInt count( KErrNone );
- TInt time( KErrNone );
- iDbManager->GetTransferInfo( ECmServiceFill, count, time );
-
- iDbManager->UpdateTransferInfo( ECmServiceFill,
- iProgressInfo.iItemsToTransferPerService, time );
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::RemoveIllegalFilenameCharactersL
-// ---------------------------------------------------------------------------
-//
-HBufC* CCmFmMain::RemoveIllegalFilenameCharactersL( const TDesC& aFileName )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::RemoveIllegalFilenameCharactersL()"));
-
- HBufC* buf = aFileName.AllocLC();
- TPtr ptr = buf->Des();
- ReplaceCharsL( ptr, KCmProk(), KCmUnderScore() ); // >
- ReplaceCharsL( ptr, KCmKorp(), KCmUnderScore() ); // <
- ReplaceCharsL( ptr, KCmQuotation(), KCmUnderScore() ); // "
- // \ character
- ReplaceCharsL( ptr, KCmDoubleBackSlash(), KCmUnderScore() );
- ReplaceCharsL( ptr, KCmSlash(), KCmUnderScore() ); // /
- ReplaceCharsL( ptr, KCmStar(), KCmUnderScore() ); // *
- ReplaceCharsL( ptr, KCmPipe(), KCmUnderScore() ); // |
- ReplaceCharsL( ptr, KCmColon(), KCmUnderScore() ); // :
- ReplaceCharsL( ptr, KCmQuestionMark(), KCmUnderScore() );// question mark
- CleanupStack::Pop(); // Can't pop by name, name invalid now
- return buf;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ReplaceCharsL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ReplaceCharsL( TDes& aString, const TDesC& aTrg,
- const TDesC& aReplacement )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ReplaceCharsL()"));
-
- __ASSERT_DEBUG( aTrg != aReplacement, User::Panic( _L( "CmFm" ), 1) );
- TPtrC ptr( aString );
- TInt position( 0 );
-
- TBool continueLoop = ETrue;
- while ( continueLoop )
- {
- TInt found = ptr.Find( aTrg );
- if( found < 0 )
- {
- continueLoop = EFalse;
- }
- else
- {
- aString.Replace( position + found, aTrg.Length(), aReplacement );
- if( position + found + aReplacement.Length() < aString.Length() )
- {
- position += found + aReplacement.Length();
- ptr.Set( aString.Mid( position ) );
- }
- else
- {
- continueLoop = EFalse;
- }
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::LoadDrivesL()
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::LoadDrivesL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::LoadDrivesL()"));
-
- iDrives.ResetAndDestroy();
- iDbManager->PrepareQueryCmdL( EDrivesQuery );
- iDbManager->QueryDrivesL( iDrives );
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::UpdateDrives()
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::UpdateDrives()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::UpdateDrives()"));
- if ( 0 != iDrives.Count() )
- {
- #ifdef _DEBUG
- TRAPD( err, iDbManager->SetDrivesL( iDrives ) );
- TRACE(Print(_L("[FILL MNGR]\t drives update err = %d"),
- err ));
- #else // _DEBUG
- TRAP_IGNORE( iDbManager->SetDrivesL( iDrives ) );
- #endif // _DEBUG
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ResolveAndAppendRootPath()
-// ---------------------------------------------------------------------------
-//
-HBufC* CCmFmMain::ResolveAndAppendRootPathL( const TInt aDriveNumber )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ResolveAndAppendRootPathL()"));
-
- HBufC* buf = HBufC::NewLC( KExtensionLength );
- TChar driveChar;
- iFsSession.DriveToChar( aDriveNumber, driveChar );
- buf->Des().Append( driveChar );
- buf->Des().Append( KCmColon );
- buf->Des().Append( KCmDoubleBackSlash );
- CleanupStack::Pop();
- return buf;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::UpdateDriveQuota()
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::UpdateDriveQuota( const TInt aDriveNumber,
- const TInt64 aQuota )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::UpdateDriveQuota()"));
-
- for( TInt i = 0 ; i < iDrives.Count(); i++ )
- {
- if( iDrives[i]->DriveNumber() == aDriveNumber )
- {
- iDrives[i]->SetUsedDriveQuota( aQuota );
- i = iDrives.Count();
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::InitializeDriveQuotasL()
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::InitializeDriveQuotasL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::InitializeDriveQuotasL()"));
-
- LoadDrivesL();
- for( TInt i = 0 ; i < iDrives.Count(); i++ )
- {
- iDrives[i]->SetUsedDriveQuota( 0 );
- }
- iDrives.ResetAndDestroy();
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::GetUsedQuota()
-// ---------------------------------------------------------------------------
-//
-TInt64 CCmFmMain::GetUsedQuota( const TInt aDriveNumber )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::GetUsedQuota()"));
-
- TInt64 quota( 0 );
- for( TInt i = 0; i < iDrives.Count(); i++ )
- {
- if( iDrives[i]->DriveNumber() == aDriveNumber )
- {
- quota = iDrives[i]->UsedDriveQuota();
- }
- }
- return quota;
- }
-
-// -----------------------------------------------------------------------------
-// CCmFmMain::CreateRFile()
-// -----------------------------------------------------------------------------
-//
-TInt CCmFmMain::CreateRFile( const TDesC& aFilePath )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::CreateRFile()"));
-
- iFile.Close();
- TRACE(Print(_L("[FILL MNGR]\t Creating file : %S"), &aFilePath ));
- TInt error(iFile.Create( iFsSession, aFilePath, EFileWrite ));
- if( KErrAlreadyExists == error )
- {
- TRACE(Print(_L("[FILL MNGR]\t Allready exists => delete old file") ));
- error = iFsSession.Delete( aFilePath );
- error = iFile.Create( iFsSession, aFilePath, EFileWrite );
- }
- TRACE(Print(_L("[FILL MNGR]\t CreateRFile err: %d"), error ));
- return error;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::PrivatePathL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::PrivatePathL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::PrivatePathL()"));
-
- iFullPath.Zero();
- HBufC* temp = ResolveAndAppendRootPathL( iItems[ iIndex ]->DriveNumber() );
- CleanupStack::PushL( temp );
- iFullPath.Append( *temp );
- CleanupStack::PopAndDestroy( temp );
-
- TFileName privatePath;
- TInt err = iFsSession.PrivatePath( privatePath );
- if ( !err )
- {
- iFullPath.Append( privatePath.Mid( 1 ) );
-
- // Now the path contains everything but filename and extension
- // => check that the directory exists. If not, it will be created.
- // Possible error is ignored at the moment
- // (normal case is KErrAlreadyExists)
- err = iFsSession.MkDirAll( iFullPath );
-
- iFullPath.Append( KCmFmTempFile() );
- }
- LOG(_L("[FILL MNGR]\t CCmFmMain::PrivatePath() end"));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ReplaceFileL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ReplaceFileL( const TDesC& aOriginal )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ReplaceFileL()"));
-
- HBufC* temp = ResolveAndAppendRootPathL(
- iItems[ iIndex ]->DriveNumber() );
-// CleanupStack::PushL( temp );
- temp = temp->ReAllocL( temp->Length() + aOriginal.Length() );
- temp->Des().Append( aOriginal );
-
- TInt error = iFsSession.Replace( iFullPath, *temp );
- if( error == KErrPathNotFound )
- {
- error = iFsSession.MkDirAll( *temp );
- TRACE(Print(_L("[FILL MNGR]\t MkDir err: %d"), error ));
-
- error = iFsSession.Replace( iFullPath, *temp );
- TRACE(Print(_L("[FILL MNGR]\t MkDir err: %d"), error ));
- }
- iFullPath.Copy( *temp );
- delete temp;
-// CleanupStack::PopAndDestroy( temp );
-
- TRACE(Print(_L("[FILL MNGR]\t File Replace done err: %d"), error ));
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::CheckServerIndex
-// ---------------------------------------------------------------------------
-//
-TInt CCmFmMain::CheckServerIndex( const TDesC8& aUuid,
- const CUpnpAVDeviceList& aList )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::CheckServerIndex()"));
-
- TInt index( KErrNotFound );
- for( TInt i = 0; i < aList.Count(); i++ )
- {
- if( KErrNotFound != aList[i]->Uuid().Match( aUuid ) )
- {
- index = i;
- i = aList.Count();
- }
- }
- return index;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::NeededServerAvailableL
-// ---------------------------------------------------------------------------
-//
-TBool CCmFmMain::NeededServerAvailableL( )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::NeededServerAvailableL()"));
-
- TBool available( EFalse );
- TInt index( 0 );
- for( TInt i = 0 ; i < iDevices->Count(); i++ )
- {
- index =
- iCmFmFillRuleFilledDataMngr->GetMediaServerIdL(
- (*iDevices)[i]->Uuid() );
- if( index != KErrNotFound )
- {
- available = ETrue;
- i = iDevices->Count();
- LOG(_L("[FILL MNGR]\t Server available."));
- }
- }
- return available;
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ResetItems
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ResetItems()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ResetItems()"));
-
- iItems.ResetAndDestroy();
- iItems.Close();
- iToBeDeleted.ResetAndDestroy();
- iToBeDeleted.Close();
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::ResetDeleteQueue
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::ResetDeleteQueue( )
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::ResetDeleteQueue()"));
-
- if( iArray )
- {
- iArray->Reset();
- delete iArray;
- iArray = NULL;
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::AddFilesToDeleteQueueL
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::AddFilesToDeleteQueueL()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::AddFilesToDeleteQueueL()"));
-
- iArray = new ( ELeave ) CDesCArrayFlat( 10 );
- HBufC* temp = NULL;
- TFileName path;
- TInt64 totalSize( KErrNone );
- TBool drivechange( EFalse );
- for( TInt i = 0; i < iToBeDeleted.Count(); i++ )
- {
- if( KErrNone == iToBeDeleted[i]->RefId() )
- {
- drivechange = ETrue;
- temp = ResolveAndAppendRootPathL(
- iToBeDeleted[i]->DriveNumber() );
- path.Append( *temp );
- path.Append( iToBeDeleted[i]->Path() );
- iArray->AppendL( path );
- delete temp;
- path.Zero();
-
- totalSize = GetUsedQuota(
- iToBeDeleted[i]->DriveNumber() );
- totalSize -= iToBeDeleted[i]->Size();
- UpdateDriveQuota( iToBeDeleted[i]->DriveNumber(),
- totalSize );
- }
- }
-
- if( drivechange )
- {
- UpdateDrives();
- }
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::StopItemCheck
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::StopItemCheck()
- {
- if( KErrNone < iItems.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateFillItems();
- }
- if( KErrNone < iToBeDeleted.Count() )
- {
- iCmFmFillRuleFilledDataMngr->UpdateToBeDeleted(
- iToBeDeleted );
- }
- iCmFmDownloadProxy->CancelOperation();
- iFullPath.Zero();
- if( iDevices )
- {
- iDevices->ResetAndDestroy();
- }
- delete iDevices;
- iDevices = NULL;
- UpdateDrives();
- iDrives.ResetAndDestroy();
- iToBeDeleted.ResetAndDestroy();
- ResetDeleteQueue();
- }
-
-// ---------------------------------------------------------------------------
-// CCmFmMain::Close
-// ---------------------------------------------------------------------------
-//
-void CCmFmMain::Close()
- {
- LOG(_L("[FILL MNGR]\t CCmFmMain::Close()"));
-
- delete this;
- }
-
-// ---------------------------------------------------------------------------
-// CompareById
-// For sort. Sort is based on db id
-// ---------------------------------------------------------------------------
-//
-TInt CCmFmMain::CompareById( const CCmFillListItem& aItem1,
- const CCmFillListItem& aItem2 )
- {
- TInt result = 0;
-
- if ( aItem1.DbId() < aItem2.DbId() )
- {
- result = -1;
- }
- else if ( aItem1.DbId() > aItem2.DbId() )
- {
- result = 1;
- }
-
- return result;
- }
-
-// ---------------------------------------------------------------------------
-// CompareBySize
-// For sort. Sort is based on item size
-// ---------------------------------------------------------------------------
-//
-TInt CCmFmMain::CompareBySize( const CCmFillListItem& aItem1,
- const CCmFillListItem& aItem2 )
- {
- TInt result = 0;
-
- if ( aItem1.Size() < aItem2.Size() )
- {
- result = -1;
- }
- else if ( aItem1.Size() > aItem2.Size() )
- {
- result = 1;
- }
-
- return result;
- }
-
-// End of file
-