/*

* 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:  Collection Ui Helper implementation

*

*/

#include <e32base.h>

#include <s32file.h>

#include <mpxmedia.h>

#include <mpxcollectionplaylist.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxuser.h>

#include <mpxcmn.h>

#include <mpxcollectionutility.h>

#include <mpxcollectiontype.h>

#include <mpxcollectionmediator.h>

#include <mpxplaylistenginedefs.h>

#include <mpxlog.h>

#include <mpxcollectionmessage.h>

#include <mpxtaskqueue.h>

#include <mpxcollectionplugin.hrh>

#include <mpxharvesterutility.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <mtpprivatepskeys.h>

#include "mpxcollectionuihelperobserver.h"

#include "mpxcollectionuihelperimp.h"

#include "mpxcollectionhelpercommon.h"

#include "mpxdeletehelper.h"

// CONSTANTS

const TInt KMPXAllSongsViewIndex = 0;

const TInt KMPXPlaylistViewIndex = 1;

const TInt KMPXRecentlyPlayedIndex = 0x20000000;

const TInt KMPXMostPlayedIndex = 0x20000001;

const TInt KMPXRecentlyAddedIndex = 0x20000002;

_LIT( KPathVirtualPlaylistHandling, "openpath.dat");

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

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

// Private Constructor

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

//

CMPXCollectionUiHelperImp::CMPXCollectionUiHelperImp()

    {

    }

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

// 2nd Phase Constructor

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

//

void CMPXCollectionUiHelperImp::ConstructL(const TUid& aModeId)

    {

    iCollection = MMPXCollectionUtility::NewL(this,aModeId);

    iMediator = CMPXCollectionMediator::NewL( iCollection->Collection(),

                                              this );

    iHarvester = CMPXHarvesterFactory::NewL();

    iTaskQueue = CMPXActiveTaskQueue::NewL();

    iDeleteHelper = CMPXDeleteHelper::NewL(*iCollection, *iHarvester, *this);

    iRemainder = 0;

    iTotalChunkNumber = 0;

    iChunkNumber = 0;

    iChunkSize = 0;

    iArrayIndex = 0;

    iRefCount = 1;

    }

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

// Two-Phased Constructor

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

//

CMPXCollectionUiHelperImp* CMPXCollectionUiHelperImp::NewL(const TUid& aModeId)

    {

    CMPXCollectionUiHelperImp* self = CMPXCollectionUiHelperImp::NewLC(aModeId);

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-Phased Constructor

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

//

CMPXCollectionUiHelperImp* CMPXCollectionUiHelperImp::NewLC(const TUid& aModeId)

    {

	CMPXCollectionUiHelperImp* self(NULL);

    if ( aModeId == KMcModeDefault )

        {

    	self = reinterpret_cast<CMPXCollectionUiHelperImp*>(Dll::Tls());

    	if ( !self )

            {

            self = new( ELeave ) CMPXCollectionUiHelperImp();

            CleanupStack::PushL( self );

			self->ConstructL(aModeId);

            Dll::SetTls( self );

            }

        else

            {

            self->iRefCount++;

            CleanupStack::PushL( self );

            }

		return self;

        }

    else

		{

		self = new( ELeave ) CMPXCollectionUiHelperImp();

		CleanupStack::PushL( self );

		self->ConstructL(aModeId);

		return self;

		}

    }

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

// Virtual Destructor

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

//

CMPXCollectionUiHelperImp::~CMPXCollectionUiHelperImp()

    {

    delete iMediator;

    if( iCollection )

        {

        iCollection->Close();

        }

    if( iHarvester )

        {

        iHarvester->Close();

        }

    delete iTaskQueue;

    delete iMedia;

    delete iDeleteHelper;

    delete iInputMedia;

    }

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

// Issue collection initialization command to collection framework.

// This is necessary when collection helper serves as an intermediator

// between collection framework and Podcast App or MTP, etc.

// There is, currently, no way to check the merge status of the collections

// through the collection utility API.  Therefore, collectionhelper issue

// an EMcCmdCollectionInit(or merge) command before any collectionhelper

// functionality, which expects collection is in valid state, is excuted.

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

//

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

// Add a Media to the collection

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

//

void CMPXCollectionUiHelperImp::AddL( const CMPXMedia& aMedia,

                                MMPXCHelperObserver* aObserver )

    {

    if (!aObserver)

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media doesn't contain the following attributes

    //

    if (!aMedia.IsSupported(KMPXMediaGeneralType) ||

        !aMedia.IsSupported(KMPXMediaGeneralCategory))

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media isn't a playlist (i.e. type must be EMPXItem and category

    // must be EMPXPlaylist

    //

    TMPXGeneralType mediaType =

         aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);

    TMPXGeneralCategory mediaCategory =

         aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

    //

    // currently only supporting playlists

    //

    if ( mediaType != EMPXItem ||

         mediaCategory != EMPXPlaylist )

        {

        User::Leave( KErrNotSupported );

        }

    //

    // leave if the media doesn't contain mandatory attributes for adding a playlist

    // or adding (appending) tracks to an existing playlist.

    // Required attributes for adding a new playlist are:

    //  type, category, array contents, array counts, title, and path for playlist

    // Required attributes for adding tracks to an existing playlist are:

    //  type, category, array contents, array counts, and playlist Id

    //

    if (!aMedia.IsSupported(KMPXMediaArrayContents) ||

        !aMedia.IsSupported(KMPXMediaArrayCount))

        {

        User::Leave( KErrArgument );

        }

    TInt task(ETaskNone);

    if (!aMedia.IsSupported(KMPXMediaGeneralId))

        {

        if (!aMedia.IsSupported(KMPXMediaGeneralTitle) ||

            !aMedia.IsSupported(KMPXMediaGeneralUri))

            {

            User::Leave( KErrArgument );

            }

        else

            {

            task = ETaskAddMedia;

            }

        }

    else

        {

        task = ETaskAppendMedia;

        }

    //

    // externalize parameters

    //

    CBufBase* taskParam(NULL);

    ::CreateBufferL<CMPXMedia>( aMedia, taskParam );

    CleanupStack::PushL(taskParam);

    // Increase reference count for task queue

    CMPXMedia* ref = CMPXMedia::NewL( aMedia );

    CleanupStack::PushL(ref);

    //

    // add request to the task queue

    //

    iTaskQueue->AddTaskL( task,

                          aObserver,   // callback when task completed

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data

                          ref );       // ownership transferred

    CleanupStack::Pop(2, taskParam);   // ref & task Param

    }

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

// Increment Addition

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

//

void CMPXCollectionUiHelperImp::IncAddL( const CMPXMedia& aMedia,

                                         MMPXCHelperObserver* aObserver,

                                         const TInt aSize )

    {

    if (!aObserver)

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media doesn't contain the following attributes

    //

    if (!aMedia.IsSupported(KMPXMediaGeneralType) ||

        !aMedia.IsSupported(KMPXMediaGeneralCategory))

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media isn't a playlist (i.e. type must be EMPXItem and category

    // must be EMPXPlaylist

    //

    TMPXGeneralType mediaType =

         aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);

    TMPXGeneralCategory mediaCategory =

         aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

    //

    // currently only supporting playlists

    //

    if ( mediaType != EMPXItem ||

         mediaCategory != EMPXPlaylist )

        {

        User::Leave( KErrNotSupported );

        }

    //

    // leave if the media doesn't contain mandatory attributes for adding a playlist

    // or adding (appending) tracks to an existing playlist.

    // Required attributes for adding a new playlist are:

    //  type, category, array contents, array counts, title, and path for playlist

    // Required attributes for adding tracks to an existing playlist are:

    //  type, category, array contents, array counts, and playlist Id

    //

    if (!aMedia.IsSupported(KMPXMediaArrayContents) ||

        !aMedia.IsSupported(KMPXMediaArrayCount))

        {

        User::Leave( KErrArgument );

        }

    TInt task(ETaskNone);

    if (!aMedia.IsSupported(KMPXMediaGeneralId))

        {

        if (!aMedia.IsSupported(KMPXMediaGeneralTitle) ||

            !aMedia.IsSupported(KMPXMediaGeneralUri))

            {

            User::Leave( KErrArgument );

            }

        else

            {

            task = ETaskAddMedia;

            }

        }

    else

        {

        task = ETaskAppendMedia;

        }

    // get tracks from input media

    // since using Value instead of ValueCObject, no Push/Pop

    CMPXMediaArray* tracksArray = 

        aMedia.Value<CMPXMediaArray>( KMPXMediaArrayContents );

    // use incremental add only if number of songs > aSize

    // this is needed as IncAdd does not deal w/ the case when tracksArray->Count() == aSize

    if( tracksArray->Count() <= aSize || aSize <= 0 )

        {

        //

        // externalize parameters

        //

        CBufBase* taskParam(NULL);

        ::CreateBufferL<CMPXMedia>( aMedia, taskParam );

        CleanupStack::PushL(taskParam);

        // Increase reference count for task queue

        CMPXMedia* ref = CMPXMedia::NewL( aMedia );

        CleanupStack::PushL(ref);

        //

        // add request to the task queue

        //

        iTaskQueue->AddTaskL( task,

                              aObserver,   // callback when task completed

                              this,        // task queue observer

                              0,           // Integer paramter, not used

                              taskParam,   // task queue assumes ownership of taskParam

                              NULL,        // Ptr data 

                              ref );       // ownership transferred

        CleanupStack::Pop(2, taskParam);   // ref & task Param

        }

    else // Inc Add

        { 

        // calculate number of songs in the last chunk   

        iRemainder = tracksArray->Count() % aSize;

        // calculate the number of iterations/chunks needed to divide the songs

        // each chunk contians aSize number of songs

        if( iRemainder == 0 )

            {

            iTotalChunkNumber = tracksArray->Count() / aSize;

            }

        else

            {

            iTotalChunkNumber = tracksArray->Count() / aSize + 1;

            }

        iChunkNumber = 0;  // initialize chunk number

        iChunkSize = aSize;

        // need this in the case multiple Inc Add is called (if something leaves and

        // iInputMedia was not cleaned up properly)

        if( iInputMedia )

            {

            delete iInputMedia;

            iInputMedia = NULL;

            }

        // save needed info for subsequent processing

        iInputMedia = CMPXMedia::CopyL(aMedia);

        iArrayIndex = 0;  // index on tracksArray of the input media

        for( int i = 0; i < iTotalChunkNumber; i++ )

            {

            if( task ==  ETaskAddMedia )

                {

                // schedule the adding requests to the task queue

                iTaskQueue->AddTaskL( ETaskIncAddMedia,

                                      aObserver,   // callback when task completed

                                      this );        // task queue observer

                }

            else  // ETaskAppendMedia

                {

                // schedule the appending requests to the task queue

                iTaskQueue->AddTaskL( ETaskIncAppendMedia,

                                      aObserver,   // callback when task completed

                                      this );        // task queue observer

                }

            }

        }

    }

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

// Update a single media property

// Checks for podcast changes in gendre

// Checks for "PodCast" gendre

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

//

void CMPXCollectionUiHelperImp::SetL( CMPXMedia*& aMedia,

                                      MMPXCHelperObserver* aObserver )

    {

    MPX_FUNC("CMPXCollectionUiHelperImp::SetL");

    if (!aObserver)

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media doesn't contain the following attributes

    //

    if (!aMedia->IsSupported(KMPXMediaGeneralType) ||

        !aMedia->IsSupported(KMPXMediaGeneralCategory))

        {

        User::Leave( KErrArgument );

        }

    //

    // externalize parameters

    //

    CBufBase* taskParam(NULL);

    ::CreateBufferL<CMPXMedia>( *aMedia, taskParam );

    CleanupStack::PushL(taskParam);

    //

    // add request to the task queue

    //

    CMPXMedia* ref = CMPXMedia::NewL( *aMedia );  // ownership transferred

    CleanupStack::PushL(ref);

    iTaskQueue->AddTaskL( ETaskSetMedia,

                          aObserver,   // callback when task completed

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // ptr data

                          ref );       // keep reference count alive

    CleanupStack::Pop(2, taskParam);   // ref & taskParam

    }

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

// Update a list of medias, checks for podcast changes in genre

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

//

void CMPXCollectionUiHelperImp::SetL( TArray<CMPXMedia*>& aMediaArray,

                                CMPXCollectionPath& aPath,

                                RArray<TInt>& aIndices )

    {

    iMediator->SetItemL( aMediaArray, aPath, aIndices );

    }

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

// rename a media

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

//

void CMPXCollectionUiHelperImp::RenameL( const CMPXMedia& aMedia,

                                         MMPXCHelperObserver* aObserver )

    {

    if (!aObserver)

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media doesn't contain the following attributes

    //

    if (!aMedia.IsSupported(KMPXMediaGeneralType) ||

        !aMedia.IsSupported(KMPXMediaGeneralCategory))

        {

        User::Leave( KErrArgument );

        }

    //

    // leave if the given media isn't a playlist

    //

    TMPXGeneralType mediaType =

         aMedia.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);

    TMPXGeneralCategory mediaCategory =

         aMedia.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

    //

    // currently only supporting playlists

    //

    if ( mediaType != EMPXItem ||

         mediaCategory != EMPXPlaylist )

        {