/*

* Copyright (c) 2006 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:  Class to handle playlist extraction

*

*/

#include <e32base.h>

#include <mpxplaylistengine.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectiontype.h>

#include <mpxmediageneraldefs.h>

#include "mpxplaylistscanner.h"

#include "mpxplaylistscanobserver.h"

#include "mpxfilescanstateobserver.h"

// CONSTANTS

const TInt KExtractionCount = 2;

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

//

CMPXPlaylistScanner::CMPXPlaylistScanner( MMPXPlaylistScanObserver& aObs,

                                          MMPXFileScanStateObserver& aStateObs,

                                          RPointerArray<CMPXCollectionType>& aTypes ) : 

                                          iObserver( aObs ),

                                          iStateObserver( aStateObs ),

                                          iSupportedTypes(aTypes)

    {

    }

// ---------------------------------------------------------------------------

// 2nd phase constructor

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::ConstructL()

    {

    iPlEngine = CMPXPlaylistEngine::NewL( *this );

    iPlList = new(ELeave) CDesCArrayFlat(1); // granularity

    iPlUpdateList = new(ELeave) CDesCArrayFlat(1); // granularity

    iPropArray = CMPXMediaArray::NewL();

    iUpdatePropArray = CMPXMediaArray::NewL();

    }

// ---------------------------------------------------------------------------

// Two Phased Constructor

// ---------------------------------------------------------------------------

//

CMPXPlaylistScanner* CMPXPlaylistScanner::NewL(

                                       MMPXPlaylistScanObserver&  aObs,

                                       MMPXFileScanStateObserver& aStateObs,

                                       RPointerArray<CMPXCollectionType>& aTypes )

    {

    CMPXPlaylistScanner* self = new(ELeave) CMPXPlaylistScanner( aObs,

                                                                 aStateObs,

                                                                 aTypes );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Virtual destructor

// ---------------------------------------------------------------------------

//

CMPXPlaylistScanner::~CMPXPlaylistScanner()

    {

    if( iPlList )

        {

        iPlList->Reset();

        delete iPlList;

        }

    if( iPlUpdateList )

        {

        iPlUpdateList->Reset();

        delete iPlUpdateList;

        }

    if( iPropArray )

        {

        iPropArray->Reset();

        }

    delete iPropArray;

    if( iUpdatePropArray )

        {

        iUpdatePropArray->Reset();

        }

    delete iUpdatePropArray;

    if( iPlEngine )

        {

        iPlEngine->CancelRequests();     

        }

    delete iPlEngine;

    }

// ---------------------------------------------------------------------------

// Start the playlist scanning procedure

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::ScanL()

    {

    iNewPlPending = iPlList->Count();

    iUpdatePlPending = iPlUpdateList->Count();

    // Add all files in the list to the playlist engine queue.

    //

    if( iNewPlPending || iUpdatePlPending )

        {

        for( TInt i=0; i<iNewPlPending; ++i )

            {

            iPlEngine->InternalizePlaylistL( (*iPlList)[i] );

            }

        for( TInt i=0; i<iUpdatePlPending; ++i )

            {

            iPlEngine->InternalizePlaylistL( (*iPlUpdateList)[i] );

            }

        iExtracting = ETrue;

        }

    // No files to extract

    // 

    else

        {

        iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanPlaylists,

                                                  KErrNone );    

        }   

    }

// ---------------------------------------------------------------------------

// Cancel the playlist scanning procedure

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::Cancel()

    {

    if( iExtracting )

        {

        iPlEngine->CancelRequests(); 

        iExtracting = EFalse;

        TRAP_IGNORE(iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanPlaylists, 

                                                             KErrCancel );  

                    );      

        }

    }

// ---------------------------------------------------------------------------

// Reset the object

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::Reset()

    {

    iPlList->Reset();

    iPlUpdateList->Reset();

    iPropArray->Reset();

    iUpdatePropArray->Reset();

    }

// ---------------------------------------------------------------------------

// Add a file to the list to be extracted

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::AddPlaylistToScanL( const TDesC& aFile )

    {

    iPlList->AppendL( aFile );

    }

// ---------------------------------------------------------------------------

// Add a file to the list to be updated

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::AddUpdatedPlaylistToScanL( const TDesC& aFile )

    {

    iPlUpdateList->AppendL( aFile );

    }

// ---------------------------------------------------------------------------

// Handles playlist import

// Note: aCompleted is not in use for Increment 8, for future usage.

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::HandlePlaylistL( CMPXMedia* aPlaylist,

                                           const TInt aError,

                                           const TBool /*aCompleted*/ )

    {

    // Only add parsable playlists

    //     

    if( aError == KErrNone )

        {

        // We take ownership of the media object

        //

        CleanupStack::PushL( aPlaylist );

        // Find what collection this belongs to

        //

        const TDesC& file = aPlaylist->ValueText( 

                     TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralUri));

        TParsePtrC parse( file );

        TInt index(KErrNotFound); 

        TInt count( iSupportedTypes.Count() );

        for (TInt i=0; i <count; ++i)

            {

            TInt index2(KErrNotFound);    

            const CDesCArray& exts = iSupportedTypes[i]->Extensions();

            if (!exts.FindIsq(parse.Ext(), index2))

                { // found 

                index = i;

                break;

                }

            }

        // Found?

        if( index == KErrNotFound )

            {

            // Unsupported by a collection

            //

            CleanupStack::PopAndDestroy( aPlaylist );      

            }

        else

            {

            // Set collection ID and add to array

            //

            aPlaylist->SetTObjectValueL( TMPXAttribute( KMPXMediaIdGeneral, 

                                             EMPXMediaGeneralCollectionId),

                                         iSupportedTypes[index]->Uid() );

            if( iNewPlPending )

                {

                iPropArray->AppendL( aPlaylist );  // owned by array

                }

            else

                {

                iUpdatePropArray->AppendL( aPlaylist ); // owned by array

                } 

            CleanupStack::Pop( aPlaylist );

            }

        }

    else // an error occured

        {

        // Playlist engine should have set this to NULL

        // (Just in case)

        delete aPlaylist; 

        }

    if( iNewPlPending )

        {

        iNewPlPending--;

        }

    else // Some update ones pending

        {

        iUpdatePlPending--;    

        }

    // All done!

    //

    TInt pending = iNewPlPending + iUpdatePlPending;  

    if( pending == 0 && iExtracting )

        {

        CompleteFilesL();

        iExtracting = EFalse;

        iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanPlaylists, 

                                                 KErrNone );

        }

    // Enough to send to the collection

    //

    else if( iPropArray->Count() + iUpdatePropArray->Count() 

             == KExtractionCount )

        {

        CompleteFilesL();

        }

    } //lint !e961

// ---------------------------------------------------------------------------

// Handles Playlist export to a file

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::HandlePlaylistL(const TDesC& /*aPlaylistUri*/,

                                          const TInt /*aError*/)

    {

    // not used

    }

// ---------------------------------------------------------------------------

// Checks if a file is a playlist file 

// ---------------------------------------------------------------------------

//

TBool CMPXPlaylistScanner::IsPlaylistFileL( const TDesC& aFile )

    {

    return iPlEngine->IsPlaylistL( aFile );

    }

// ---------------------------------------------------------------------------

// Upload the next list of files

// ---------------------------------------------------------------------------

//

void CMPXPlaylistScanner::CompleteFilesL()

    {

    TInt err(KErrNone);

    if( iPropArray->Count() )

        {

        TRAP( err, iObserver.AddPlaylistToCollectionL( *iPropArray ) );

        }

    if( iUpdatePropArray->Count() )

        {

        TRAP( err, iObserver.UpdatePlaylistToCollectionL( *iUpdatePropArray ) );

        }

    if( err != KErrNone )

        {

        // Cancel requests and notify end

        iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanPlaylists, 

                                                  err );        

        iPlEngine->CancelRequests();        

        }

    Reset();

    }