/*
* 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