/*

* 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:  Helper class to move items to different collections

*

*/

#include <e32base.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionutility.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxcollectionplugin.hrh>

#include <mpxplaybackutility.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include "mpxmediatorobserver.h"

#include "mpxmoveobserver.h"

#include "mpxmoveitemhelper.h"

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

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

// Constructor

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

//

CMPXMoveItemHelper::CMPXMoveItemHelper( MMPXMoveItemObserver* aObs )

                                                          : iObs(aObs),

                                                            iMoveState(EIdle )

    {

    }

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

// 2nd phased constructor

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

//

void CMPXMoveItemHelper::ConstructL()

    {

    iCollection = MMPXCollectionUtility::NewL( NULL );

    RArray<TUid> ary;

    CleanupClosePushL( ary );

    ary.AppendL( TUid::Uid(EMPXCollectionPluginPodCast) );

    iPodCastCollectionID = iCollection->CollectionIDL( ary.Array() );

    ary.Reset();

    ary.AppendL( TUid::Uid(EMPXCollectionPluginMusic) );

    iMusicCollectionID = iCollection->CollectionIDL( ary.Array() );

    CleanupStack::PopAndDestroy( &ary );

    }

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

// Two phase constructor

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

//

EXPORT_C CMPXMoveItemHelper* CMPXMoveItemHelper::NewL( MMPXMoveItemObserver* aObs )

    {

    CMPXMoveItemHelper* self = CMPXMoveItemHelper::NewLC(aObs);

    CleanupStack::Pop( self );

    return self;

    }

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

// Two phased constructor

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

//

EXPORT_C CMPXMoveItemHelper* CMPXMoveItemHelper::NewLC( MMPXMoveItemObserver* aObs )

    {

    CMPXMoveItemHelper* self = new( ELeave ) CMPXMoveItemHelper(aObs);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// virtual destructor

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

//

CMPXMoveItemHelper::~CMPXMoveItemHelper()

    {

    if( iCollection )

        {

        iCollection->Close();

        }

    }

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

// Move an item synchronously

// Three things to do to move an item

// 1: Remove item from old db

// 2: Udpdate media with new collection id

// 3: Add item into new db

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

//

EXPORT_C void CMPXMoveItemHelper::MoveItemL( CMPXMedia& aMedia, TUid aNewCollection )

    {

    MMPXPlaybackUtility* pbUtil = MMPXPlaybackUtility::UtilityL( KPbModeActivePlayer );

    CleanupClosePushL(*pbUtil);

    // Media as a container or item

    //

    TMPXGeneralType type =

         aMedia.ValueTObjectL<TMPXGeneralType>( TMPXAttribute( KMPXMediaIdGeneral,

                                                               EMPXMediaGeneralType ) );

    if ( type == EMPXGroup )

        {

        const CMPXMediaArray* array = aMedia.Value<CMPXMediaArray>(

                                TMPXAttribute( KMPXMediaIdContainer,

                                               EMPXMediaArrayContents ) );

        if( !array )

            {

            User::Leave( KErrNoMemory );

            }

        TInt count( array->Count() );

        if( count == 0 )

            {

            User::Leave( KErrNotFound );

            }

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

            {

            CMPXMedia* entry = array->AtL(i);

            // Notify the playback utility before removing the media item

            if(entry->IsSupported(KMPXMediaGeneralId))

                {

                TMPXItemId mediaId(entry->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

                TRAP_IGNORE(pbUtil->CommandL( EPbCmdCloseItem, mediaId));

                }

            TUid oldCollection = entry->ValueTObjectL<TUid>(TMPXAttribute(KMPXMediaIdGeneral,

                                                                          EMPXMediaGeneralCollectionId));

            DoRemoveL( entry, oldCollection );

            entry->SetTObjectValueL<TUid>(TMPXAttribute(KMPXMediaIdGeneral,

                                                       EMPXMediaGeneralCollectionId),

                                         aNewCollection);

            UpdateMediaForMoveL( *entry, oldCollection, aNewCollection );

            DoAddL( entry, aNewCollection );

            }

        }

    else

        {

        TUid oldCollection = aMedia.ValueTObjectL<TUid>(TMPXAttribute(KMPXMediaIdGeneral,

                                                                      EMPXMediaGeneralCollectionId));

        aMedia.SetTObjectValueL<TUid>(TMPXAttribute(KMPXMediaIdGeneral,

                                                    EMPXMediaGeneralCollectionId),

                                      aNewCollection);

        if(aMedia.IsSupported(KMPXMediaGeneralId))

            {

            TMPXItemId mediaId(aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

            TRAP_IGNORE(pbUtil->CommandL( EPbCmdCloseItem, mediaId));

            }

        DoRemoveL( &aMedia, oldCollection );

        UpdateMediaForMoveL( aMedia, oldCollection, aNewCollection );

        DoAddL( &aMedia, aNewCollection );

        }

    CleanupStack::PopAndDestroy(pbUtil);

    }

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

// Fetch an item then move it async

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

//

EXPORT_C void CMPXMoveItemHelper::FetchAndMoveItemL( const CMPXMedia& aMedia,

                                                     TUid aNewCollection )

    {

    ASSERT( iMoveState == EIdle );

    ASSERT( iObs );

    // Fetch item from collection asynchronously

    //

    // Look for the item, and fetch all relavant info

    //

    RArray<TMPXAttribute> atts;

    CleanupClosePushL( atts );

    atts.Append(KMPXMediaGeneralAll);

    atts.Append(KMPXMediaAudioAudioAll);

    atts.Append(KMPXMediaMusicAll);

    iCollection->Collection().FindAllL( aMedia, atts.Array(), *this );

    CleanupStack::PopAndDestroy( &atts );

    iMoveState = EFind;

    iMoveTarget = aNewCollection;

    }

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

// Fetch an item then move it sync

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

//

EXPORT_C void CMPXMoveItemHelper::FetchAndMoveItemSyncL( const CMPXMedia& aMedia,

                                                TUid aNewCollection )

    {

    // Look for the item, and fetch all relavant info

    //

    RArray<TMPXAttribute> atts;

    CleanupClosePushL( atts );

    atts.Append(KMPXMediaGeneralAll);

    atts.Append(KMPXMediaAudioAudioAll);

    atts.Append(KMPXMediaMusicAll);

    CMPXMedia* result = iCollection->Collection().FindAllL( aMedia,

                                                            atts.Array() );

    CleanupStack::PopAndDestroy( &atts );

    CleanupStack::PushL( result );

    // Move the item as normal

    MoveItemL( *result, aNewCollection );

    CleanupStack::PopAndDestroy( result );

    }

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

// Updates a media object for collection specific detail

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

//

void CMPXMoveItemHelper::UpdateMediaForMoveL( CMPXMedia& aMedia,

                                              TUid& aOldCollection,

                                              TUid& aNewCollection )

    {

    // If we are moving from podcast collection -> local audio

    //

    if( aNewCollection == iMusicCollectionID &&

        aOldCollection == iPodCastCollectionID )

        {

        aMedia.SetTObjectValueL(TMPXAttribute(KMPXMediaIdGeneral,

                                               EMPXMediaGeneralCategory),

                                 EMPXSong);

        }

    // Move from local collection -> podcast

    //

    else if( aOldCollection == iMusicCollectionID &&

             aNewCollection == iPodCastCollectionID )

        {

        aMedia.SetTObjectValueL(TMPXAttribute(KMPXMediaIdGeneral,

                                         EMPXMediaGeneralCategory),

                                 EMPXPodcast);

        }

    } //lint !e961

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

// Add an item to the collection

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

//

void CMPXMoveItemHelper::DoAddL( CMPXMedia* aMedia, TUid aCollectionId )

    {

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionAdd );

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, aCollectionId.iUid );

    cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, aMedia );

    iCollection->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    }

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

// Set an item to the collection

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

//

void CMPXMoveItemHelper::DoRemoveL( CMPXMedia* aMedia, TUid aCollectionId )

    {

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionRemoveMedia );

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL( KMPXCommandCollectionRemoveMediaDeleteRecord, ETrue );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, aCollectionId.iUid );

    cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandCollectionRemoveMedia, aMedia );

    iCollection->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    }

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

// Handle find all callback

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

//

void CMPXMoveItemHelper::HandleFindAllL( const CMPXMedia& aResults,

                                         TBool /*aComplete*/,TInt aError)

    {

    // Make sure the mode is correct

    ASSERT( iMoveState == EFind );

    TInt err ( aError );

    if( err == KErrNone )

        {

        TRAP( err, DoHandleFindAllL( aResults ) );

        }

    // Find all is the most time consuming part.

    //

    iObs->HandleMoveCompleteL( err );

    iMoveState = EIdle;

    }

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

// Handle find all callback

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

//

void CMPXMoveItemHelper::DoHandleFindAllL( const CMPXMedia& aResult )

    {

    // Need to make a tmp copy because we have to modify collection id

    //

    CMPXMedia* tmp = CMPXMedia::NewL();

    CleanupStack::PushL( tmp );

    *tmp = aResult;

    MoveItemL( *tmp, iMoveTarget );

    CleanupStack::PopAndDestroy( tmp );

    }

// End of file