/*
* 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: Store music file processing
* Version : %version: tr1ido#9.1.2 % << Don't touch!
*
*/
#include <ContentListingFactory.h>
#include <MCLFContentListingEngine.h>
#include <MCLFItem.h>
#include <MCLFSortingStyle.h>
#include "upnpfileutility.h"
#include "cmstorelistitem.h"
#include "cmsmfilemngr.h"
#include "cmsmclfmngr.h"
#include "msdebug.h"
// CONSTANTS
_LIT( KCmSmIconExtension, ".fil" );
_LIT( ROM1, "Z" );
_LIT( ROM2, "z" );
// Once filter maximum count;
const TInt KFilterMaxCount = 10;
// ---------------------------------------------------------------------------
// CCmSmClfMngr::NewL
// ---------------------------------------------------------------------------
//
CCmSmClfMngr* CCmSmClfMngr::NewL( MCmSmMusicMngrObserver& aObserver,
CCmSmFileMngr& aFileMngr, RPointerArray<CCmStoreListItem>& aItems )
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::NewL() start"));
CCmSmClfMngr* self = CCmSmClfMngr::NewLC(
aObserver, aFileMngr, aItems );
CleanupStack::Pop( self );
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::NewL() end"));
return self;
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::NewLC
// ---------------------------------------------------------------------------
//
CCmSmClfMngr* CCmSmClfMngr::NewLC( MCmSmMusicMngrObserver& aObserver,
CCmSmFileMngr& aFileMngr, RPointerArray<CCmStoreListItem>& aItems )
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::NewLC() start"));
CCmSmClfMngr* self = new ( ELeave ) CCmSmClfMngr(
aObserver, aFileMngr, aItems );
CleanupStack::PushL( self );
self->ConstructL();
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::NewLC() end"));
return self;
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::~CCmSmClfMngr
// ---------------------------------------------------------------------------
//
CCmSmClfMngr::~CCmSmClfMngr()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::\
~CCmSmClfMngr() start"));
Cancel();
CancelClfRefresh();
delete iNewAudioItems;
delete iNewImageItems;
delete iNewVideoItems;
delete iEngine;
delete iSortingStyle;
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::\
~CCmSmClfMngr() end"));
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::CCmSmClfMngr
// ---------------------------------------------------------------------------
//
CCmSmClfMngr::CCmSmClfMngr( MCmSmMusicMngrObserver& aObserver,
CCmSmFileMngr& aFileMngr, RPointerArray<CCmStoreListItem>& aItems )
:CActive( EPriorityStandard ),
iObserver( aObserver ), iFileMngr( aFileMngr ),
iItems( aItems )
{
CActiveScheduler::Add( this );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::ConstructL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::ConstructL()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::ConstructL()"));
iEngine = ContentListingFactory::NewContentListingEngineLC();
CleanupStack::Pop();
iNewAudioItems = iEngine->CreateListModelLC( *this );
CleanupStack::Pop();
// Creating a temporary pointer since ContentListingFactory interface
// forces us to use LC-method and we don't want to assign an member
// variable with LC-method.
MCLFSortingStyle* sortingStyle =
ContentListingFactory::NewSortingStyleLC();
CleanupStack::Pop(); // can't pop by name here
iSortingStyle = sortingStyle;
sortingStyle = NULL;
iSortingStyle->SetOrdering( ECLFOrderingAscending );
iSortingStyle->SetSortingDataType( ECLFItemDataTypeDesC );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::CancelClfRefresh
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::CancelClfRefresh()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::CancelClfRefresh()"));
if( iNewAudioItems )
{
iNewAudioItems->CancelRefresh();
}
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::CancelOperation
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::CancelOperation()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::CancelOperation"));
if ( IsActive() )
{
Cancel();
}
CancelClfRefresh();
iObserver.MusicReady( ECmSmProcessingCanceled );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::SetupCLFListModelsL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::SetupCLFListModelsL( TCmMediaType aMediaType )
{
LOG(_L("[STORE MNGR]\t SetupCLFListModelsL"));
RArray< TInt > mediaTypes;
CleanupClosePushL( mediaTypes );
switch(aMediaType)
{
case ECmAudio:
{
mediaTypes.AppendL( ECLFMediaTypeMusic );
mediaTypes.AppendL( ECLFMediaTypeSound );
iNewAudioItems->SetWantedMediaTypesL( mediaTypes.Array() );
iNewAudioItems->SetSortingStyle( iSortingStyle );
break;
}
default:
{
break;
}
}
CleanupStack::PopAndDestroy( &mediaTypes );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::DoRefreshL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::DoRefreshL( TCmMediaType aMediaType )
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::DoRefreshL"));
switch( aMediaType )
{
case ECmAudio:
{
SetupCLFListModelsL( aMediaType );
iNewAudioItems->RefreshL();
break;
}
default:
{
LOG(_L("[STORE MNGR]\t DoRefreshL invariant media type"));
User::Invariant();
}
}
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::FilterItemsL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::FilterItemsL()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::DoRefreshL"));
TRACE(Print( _L("[STORE MNGR]\t Filter file start index = %d"),
iFilterIndex ) );
TCmSmFileProcessingStatus status = ECmSmNone;
if ( iFilterIndex < iNewAudioItems->ItemCount() )
{
RArray<TInt>ids;
CleanupClosePushL( ids );
iFileMngr.MediaTypesL( ids, ECmAudio );
FilterNewItemsL( iNewAudioItems, ids, ECmAudio );
CleanupStack::PopAndDestroy( &ids );
status = ECmSmContinueFiltering;
}
else
{
status = ECmSmFilteringReady;
}
TRACE(Print( _L("[STORE MNGR]\t Filter file end index = %d"),
iFilterIndex ) );
CompleteRequest( status );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::FilterNewItemsL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::FilterNewItemsL( MCLFItemListModel* aNewItems,
RArray<TInt>aDeviceIds, TCmMediaType aType )
{
LOG(_L("[STORE MNGR]\t Filtering defined media type items"));
TInt allCount = aNewItems->ItemCount();
RArray<TInt>storeIds;
CleanupClosePushL( storeIds );
RArray<TInt>storedIds;
CleanupClosePushL( storedIds );
// Copy all file names
TInt count = ( iFilterIndex + KFilterMaxCount ) <= allCount ?
KFilterMaxCount : ( allCount - iFilterIndex );
TRACE(Print( _L("[STORE MNGR]\t FilterNewItemsL file count = %d"),
count ) );
TBool drm( EFalse );
for ( TInt i = 0; i < count; i++ )
{
storeIds.Reset();
// Copy ids into temporary array
for( TInt ll = 0; ll < aDeviceIds.Count(); ll++ )
{
storeIds.Append(aDeviceIds[ll]);
}
const MCLFItem& item = aNewItems->Item( iFilterIndex );
// Fetch protection type
TPtrC fileName;
TPtrC path;
TInt32 size( 0 );
TTime date;
TPtrC album;
TPtrC mediaType;
TPtrC pathAndFileName;
TPtrC fileExtension;
User::LeaveIfError( item.GetField( ECLFFieldIdPath, path ));
User::LeaveIfError( item.GetField( ECLFFieldIdFileName, fileName ));
User::LeaveIfError( item.GetField( ECLFFieldIdFileSize, size ));
User::LeaveIfError( item.GetField( ECLFFieldIdFileDate, date ));
User::LeaveIfError( item.GetField( ECLFFieldIdFileNameAndPath,
pathAndFileName ));
User::LeaveIfError( item.GetField( ECLFFieldIdFileExtension,
fileExtension ) );
// Album list is needed for UI use
TInt error( item.GetField( ECLFFieldIdAlbum, album ) );
TRACE(Print( _L("[STORE MNGR]\t %03d: %S"), i, &fileName ) );
// If the items is not an DRM item and album isn't in excluded list,
// it is a potential candidate to be added into list of
// files to transfer.
TRAP( error, drm =
UPnPFileUtility::IsFileProtectedL( pathAndFileName ) );
TRACE( Print( _L("[STORE MNGR]\t IsFileProtectedL err = %d"), error));
if ( pathAndFileName[0] != ROM1()[0]
&& pathAndFileName[0] != ROM2()[0]
&& !drm
&& KErrNotFound == fileExtension.Match( KCmSmIconExtension ) )
{
if( iFileMngr.CheckIsFilledFileL( pathAndFileName ) )
{
storeIds.Reset();
}
iFileMngr.IsAlreadyStoreL( pathAndFileName, storedIds, storeIds );
// If file is already stored to every wanted server
// => no need to keep file on the list any longer
if( KErrNone < storeIds.Count() )
{
TCmListItemStatus status;
CCmStoreListItem* item = CCmStoreListItem::NewLC();
item->SetPrimaryTextL( fileName );
item->SetPathL( pathAndFileName );
item->SetSize( size );
item->SetDate( date );
item->SetListId( iFileMngr.RetrieveListId( aType ) );
// Ms id values are binded with file status values
iFileMngr.RetrieveListStatusValues( aType, status );
// Where item will be stored
for( TInt s = 0 ; s < storeIds.Count(); s++ )
{
item->SetDevId( storeIds[s], status );
}
// Where item has already been stored
for( TInt d = 0; d < storedIds.Count(); d++ )
{
item->SetDevId( storedIds[d], ECmStored );
}
iItems.AppendL( item );
CleanupStack::Pop( item );
}
storedIds.Reset();
}
iFilterIndex++;
}
CleanupStack::PopAndDestroy( &storedIds );
CleanupStack::PopAndDestroy( &storeIds );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::HandleOperationEventL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::HandleOperationEventL(
TCLFOperationEvent aOperationEvent, TInt aError )
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::HandleOperationEventL"));
if ( aOperationEvent == ECLFRefreshComplete )
{
switch ( aError )
{
case KErrNone:
{
CompleteRequest( ECmSmAllRefreshed );
break;
}
case KErrCancel:
{
iObserver.MusicReady( ECmSmProcessingCanceled );
break;
}
default:
{
// Notify observer.
iObserver.MusicReady( ECmSmRefreshError );
break;
}
}
}
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::CompleteRequest
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::CompleteRequest(
TCmSmFileProcessingStatus aStatus )
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::CompleteRequest"));
__ASSERT_DEBUG(!IsActive(),\
User::Panic( KCmSmManager, KErrInUse ));
SetActive();
TRequestStatus* pStatus = &iStatus;
User::RequestComplete( pStatus, aStatus );
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::RunL
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::RunL()
{
TRACE(Print(_L("[STORE MNGR]\t CCmSmClfMngr::RunL\
status = %d"), iStatus.Int() ));
switch( iStatus.Int() )
{
case ECmSmAllRefreshed:
{
CompleteRequest( ECmSmStartItemFiltering );
break;
}
case ECmSmStartItemFiltering:
{
iFilterIndex = 0;
TRACE(Print( _L("[STORE MNGR]\t Need filter file count = %d"),
iNewAudioItems->ItemCount() ) );
CompleteRequest( ECmSmContinueFiltering );
break;
}
case ECmSmContinueFiltering:
{
FilterItemsL();
break;
}
case ECmSmFilteringReady:
{
iObserver.MusicReady( KErrNone );
break;
}
default:
{
LOG(_L("[STORE MNGR]\t Store file processing RunL default"));
User::Invariant();
break;
}
}
}
// ---------------------------------------------------------------------------
// CCmSmClfMngr::DoCancel
// ---------------------------------------------------------------------------
//
void CCmSmClfMngr::DoCancel()
{
LOG(_L("[STORE MNGR]\t CCmSmClfMngr::DoCancel"));
}
// End of file