/*

* 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 for some common MPX routines

*

*/

// INCLUDES

class MMPXCollection;

#include <mpxcollectionmediator.h>

#include <mpxharvesterutility.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h> // for KMPXMediaGeneralCollectionId

#include <mpxmediacontainerdefs.h> // for KMPXMediaArrayContents

#include <mpxcollectiontype.h> // for CMPXCollectionType

#include <mpxplaylistenginedefs.h> // for EMPXPlaylistTypeM3U

#include <mpxcollectionplugin.hrh> // for EMPXCollectionPluginHidden and

#include "upnpmusicadapter.h"      // EMPXCollectionPluginTemporary

// ourselves

#include "upnpmpxhelper.h" // myself

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

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

// CUPnPMpxHelper::NewL

// 1st phase constructor.

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

//

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

    {

    CUPnPMpxHelper* self = new(ELeave)

        CUPnPMpxHelper();

    CleanupStack::PushL( self );

    self->ConstructL( aModeId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPMpxHelper::CUPnPMpxHelper

// Default constructor.

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

//    

CUPnPMpxHelper::CUPnPMpxHelper()

    {

    }

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

// CUPnPMpxHelper::ConstructL

// 2nd phase constructor

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

//    

void CUPnPMpxHelper::ConstructL( const TUid& aModeId )

    {

    iHarvester = CMPXHarvesterFactory::NewL();

    iCollectionUtil = MMPXCollectionUtility::NewL( 0, aModeId );

    iMediator = CMPXCollectionMediator::NewL( 

        iCollectionUtil->Collection(), this );

    }

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

// CUPnPMpxHelper::~CUPnPMpxHelper

// Destructor.

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

//

CUPnPMpxHelper::~CUPnPMpxHelper()

    {

    if( iHarvester )

        {

        iHarvester->Close();

        }

    if( iCollectionUtil )

        {

        iCollectionUtil->Close(); 

        }

    delete iMediator;

    }

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

// CUPnPMpxHelper::AddTrackL

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

//

void CUPnPMpxHelper::AddTrackL( CMPXMedia* aMedia )

    {

    // Add to harvester 

    TInt colUid = iHarvester->AddFileL( aMedia );

    // Add to collection, make sure we set the collection ID

    aMedia->SetTObjectValueL<TUid>(

        KMPXMediaGeneralCollectionId, TUid::Uid( colUid ) );

    iMediator->AddItemL( aMedia );

    }

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

// CUPnPMpxHelper::AddPlaylistL

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

//

void CUPnPMpxHelper::AddPlaylistL( CMPXMedia* aMedia )

    {

    // 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->Value<TMPXGeneralType>( KMPXMediaGeneralType );

    TMPXGeneralCategory mediaCategory =

        *aMedia->Value<TMPXGeneralCategory>( KMPXMediaGeneralCategory );

    if ( mediaType != EMPXItem || mediaCategory != EMPXPlaylist )

        {

        User::Leave( KErrNotSupported );

        }

    // leave if the media doesn't contain mandatory attributes

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

         !aMedia->IsSupported( KMPXMediaArrayCount ) )

        {

        User::Leave( KErrArgument );

        }

    // check if we are adding new or appending to existing

    if (!aMedia->IsSupported(KMPXMediaGeneralId))

        {

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

            !aMedia->IsSupported(KMPXMediaGeneralUri))

            {

            User::Leave( KErrArgument );

            }

        else

            {

            // adding new

            // find the collection Id

            HBufC* playlistExtension =

                iHarvester->PlaylistFileExtensionLC( EMPXPlaylistTypeM3U );

            TInt collectionId = FindCollectionIdL( *playlistExtension );                

            CleanupStack::PopAndDestroy( playlistExtension );

            // Add to collection, make sure we set the collection ID.

            aMedia->SetTObjectValueL<TUid>(

                KMPXMediaGeneralCollectionId, TUid::Uid( collectionId ));

            }

        }

    else

        {

        // appending to existing

        FillInPlaylistDetailsL( *aMedia );

        }

    iMediator->AddItemL( aMedia );

    }

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

// CUPnPMpxHelper::OpenL

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

//

void CUPnPMpxHelper::AddAndOpenL( const TUid& aHostId, CMPXMedia& aMedia )

    {

    // Grab the in memory collection plugin UID

    // aPluginInfo provides additional resolution to find the plugin

    //

    RArray<TUid> ary;

    CleanupClosePushL( ary );

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

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

    TUid inMemCollection = iCollectionUtil->CollectionIDL( ary.Array() );

    CleanupStack::PopAndDestroy( &ary );

    // First step is to add this media to the in memory plugin

    // Set the item id to be the host ID

    // 

    aMedia.SetTObjectValueL( KMPXMediaGeneralCollectionId, inMemCollection );

    aMedia.SetTObjectValueL( KMPXMediaGeneralId, aHostId.iUid );

    iCollectionUtil->Collection().AddL( aMedia );

    // Second Step is to construct collection path

    // | collection id | host id |

    //

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    path->AppendL( inMemCollection.iUid );

    path->AppendL( aHostId.iUid );

    // Last step is to open this path

    //

    iCollectionUtil->Collection().OpenL( *path );

    CleanupStack::PopAndDestroy( path );

    }

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

// retrieve collection from URI

// ResolvePlugin should be able to resolve the plugin without

// the client looking for the collection Id

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

//    

TInt CUPnPMpxHelper::FindCollectionIdL( const TDesC& aUri )   

    {

    TInt collectionId(KErrNotFound);

    TParsePtrC parser( aUri );   

    RPointerArray<CMPXCollectionType> collectionType;

    iCollectionUtil->Collection().GetSupportedTypesL(collectionType);

    TInt index(KErrNotFound);

    TInt count( collectionType.Count() );

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

        {

        const CDesCArray& extensions = collectionType[i]->Extensions();

        if (extensions.FindIsq(parser.Ext(), index) == 0)

            {

            collectionId = collectionType[i]->Uid().iUid;

            break;

            }

        }

    collectionType.ResetAndDestroy();

    return collectionId;

    }

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

// retrieve information for the required attributes

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

//

void CUPnPMpxHelper::FillInPlaylistDetailsL( CMPXMedia& aMedia )

    {

    // retrieve info about the playlist itself

    RArray<TMPXAttribute> playlistAttributes;

    CleanupClosePushL(playlistAttributes);

    playlistAttributes.AppendL(KMPXMediaGeneralId);

    playlistAttributes.AppendL(KMPXMediaGeneralTitle);

    playlistAttributes.AppendL(KMPXMediaGeneralUri);

    playlistAttributes.AppendL(KMPXMediaGeneralCollectionId);

    CMPXMedia* playlistSearchResult = iCollectionUtil->Collection()

        .FindAllL( aMedia, playlistAttributes.Array() );

    CleanupStack::PopAndDestroy(&playlistAttributes);

    CleanupStack::PushL(playlistSearchResult);

    const CMPXMediaArray* results =

        playlistSearchResult->Value<CMPXMediaArray>(KMPXMediaArrayContents);

    if ( results->Count() != 1 )

        {

        User::Leave(KErrArgument);

        }

    aMedia.SetTObjectValueL(

        KMPXMediaGeneralId, *(*results)[0]->Value<TMPXItemId>(KMPXMediaGeneralId));

    aMedia.SetTextValueL(

        KMPXMediaGeneralTitle, (*results)[0]->ValueText(KMPXMediaGeneralTitle));

    aMedia.SetTextValueL(

        KMPXMediaGeneralUri, (*results)[0]->ValueText(KMPXMediaGeneralUri));

    aMedia.SetTObjectValueL(

        KMPXMediaGeneralCollectionId, *(*results)[0]->Value<TUid>(KMPXMediaGeneralCollectionId));

    CleanupStack::PopAndDestroy(playlistSearchResult);        

    }