/*

* Copyright (c) 2006-2007 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:  provides album handling services for UPnP framework

*

*/

#include "upnpapplicationcrkeys.h" // KCRUidUPnPApplication

#include <mpxcollectionutility.h>

#include <mpxcollectionframeworkdefs.h> // main attribute keys

#include <mpxmessagegeneraldefs.h>

#include <mpxmediageneraldefs.h> // commonly used attribute keys

#include <mpxmediacontainerdefs.h> // container-specific attribute keys

#include <mpxcollectionpath.h>

#include <mpxcollectionmessage.h>

#include <mpxmediadrmdefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include "upnpalbumservices.h" // ourselves

// debug

_LIT16( KComponentLogfile, "musicadapter.txt" );

#include "upnplog.h"

// Constant definitions

#define KAlbumsCollectionUid 0x20007197 // album plugin uid

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

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

// CUPnPAlbumServices::NewL

// 1st phase constructor.

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

//

EXPORT_C CUPnPAlbumServices* CUPnPAlbumServices::NewL()

    {

    __LOG( "CUPnPAlbumServices::NewL" );

    CUPnPAlbumServices* self = new(ELeave) CUPnPAlbumServices();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPAlbumServices::CUPnPAlbumServices

// Default constructor.

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

//    

CUPnPAlbumServices::CUPnPAlbumServices() : iStatus( KErrNone )

    {

    // None.

    }

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

// CUPnPAlbumServices::ConstructL

// 2nd phase constructor

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

//    

void CUPnPAlbumServices::ConstructL()

    {

    __LOG( "CUPnPAlbumServices::ConstructL" );

    iAlbumNames = new (ELeave) CDesCArrayFlat(5);

    iAlbumIds = new (ELeave) CDesCArrayFlat(5);

    iCollectionUtility = MMPXCollectionUtility::NewL(

        (MMPXCollectionObserver*)this, KMcModePlaylist );

    // Open album collection plugin. Callback to HandleCollectionMessage.

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    path->AppendL( KAlbumsCollectionUid );

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

 	CleanupStack::PopAndDestroy( path ); 

    // Wait until signalled to proceed

    iWait = new (ELeave) CActiveSchedulerWait();    

    iWait->Start();     

    __LOG1( "CUPnPAlbumServices::ConstructL - End %d", iStatus );

    }

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

// CUPnPAlbumServices::ListAlbumsL

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

//

EXPORT_C void CUPnPAlbumServices::ListAlbumsL(

    CDesCArray& aAlbumIds,

    CDesCArray& aAlbumNames )

    {

    __LOG( "CUPnPAlbumServices::ListAlbumsL" );

    // Check if already listed

    if( iStatus != KErrNone)

        {

        __LOG1( "CUPnPAlbumServices::ListAlbumsL iStatus %d return", iStatus );

        return;

        }

    if( iAlbumNames->Count() > 0 && iAlbumIds->Count() > 0 )

        {

        __LOG( "CUPnPAlbumServices::ListAlbumsL: Already fetched." );

        // Copy from member

        TInt count = iAlbumNames->Count();

        __LOG1( "Album count=%d", count );

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

            {

            aAlbumNames.AppendL( iAlbumNames->MdcaPoint(i) );

            aAlbumIds.AppendL( iAlbumIds->MdcaPoint(i) );

            }

        __LOG( "CUPnPAlbumServices::ListAlbumsL: Return." );

        return;

        }

    CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

    CleanupStack::PushL( path );

    path->SelectAllL();

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    attrs.Append( KMPXMediaGeneralId );

    attrs.Append( KMPXMediaGeneralTitle );

    // Get album list from collection. Callback to HandleCollectionMediaL

    iCollectionUtility->Collection().MediaL( *path, attrs.Array() );

    CleanupStack::PopAndDestroy( &attrs );

    CleanupStack::PopAndDestroy( path );

    // Wait until signalled to proceed

    iWait->Start();

    if( iStatus != KErrNone )

        {

        if( iStatus == KErrNotFound )

            {

            // No albums available.

            __LOG( "ListAlbumsL: No albums available!" );

            return;

            }

        else // Some other problem

            {

            User::Leave( iStatus );

            }

        }

    if ( iMedia != 0 )

        {

        TMPXAttribute mediaArrayAttr( KMPXMediaIdContainer,

            EMPXMediaArrayContents );

        if( iMedia->IsSupported( mediaArrayAttr ) )

            {

            __LOG("getting album array");

            CMPXMediaArray* medias = iMedia->ValueCObjectL<CMPXMediaArray>(

                mediaArrayAttr );

            if( medias )

                {

                CleanupStack::PushL( medias );

                // Album count

                TInt count = medias->Count();        

                __LOG1( "Album count=%d", count );

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

                    {

                    const CMPXMedia* entry = (*medias)[i];

                    const TDesC& title = entry->ValueText(

                        KMPXMediaGeneralTitle );

                    __LOG3( "Title: %d/%d [%S]",i, count, &title );

                    TMPXItemId id = *entry->Value<TMPXItemId>(

                        KMPXMediaGeneralId );

                    aAlbumNames.AppendL( title );

                    iAlbumNames->AppendL( title ); // for later usage

                    aAlbumIds.AppendL( Id2Desc( id ) );

                    iAlbumIds->AppendL( Id2Desc( id ) ); // for later usage

                    }

                CleanupStack::PopAndDestroy( medias );

                }

            }

        else

            {

            __LOG( "getting single item" );

            const TDesC& title = iMedia->ValueText(

                KMPXMediaGeneralTitle );

            __LOG1( "Title: %S", &title );

            TMPXItemId id = *iMedia->Value<TMPXItemId>(

                KMPXMediaGeneralId );

            aAlbumNames.AppendL( title );

            iAlbumNames->AppendL( title ); // for later usage

            aAlbumIds.AppendL( Id2Desc( id ) );

            iAlbumIds->AppendL( Id2Desc( id ) ); // for later usage

            }

        delete iMedia;

        iMedia = 0;

        }

    __LOG( "CUPnPAlbumServices::ListAlbumsL -End" );

    }

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

// CUPnPAlbumServices::OpenAlbumL

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

//

EXPORT_C void CUPnPAlbumServices::OpenAlbumL(

    const TDesC& aAlbumId,

    CDesCArray& aContentMedia )

    {

    __LOG1( "CUPnPAlbumServices::OpenAlbumL(%S)", &aAlbumId );

    if( iStatus != KErrNone)

        {

        __LOG1( "CUPnPAlbumServices::OpenAlbumL iStatus %d return", iStatus );

        return;

        }

    CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

    CleanupStack::PushL( path );   

    path->AppendL( Desc2Id( aAlbumId ) );

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

 	CleanupStack::PopAndDestroy( path );

 	// Wait until signalled to proceed

    iWait->Start();

 	if( iStatus != KErrNone )

        {

        // Open album failed.

        User::Leave( iStatus );

        }

    CMPXCollectionPath* mediaPath = iCollectionUtility->Collection().PathL();

    CleanupStack::PushL( mediaPath );

    mediaPath->SelectAllL();

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    attrs.Append( KMPXMediaGeneralUri );

    // Get metadata of given album. Callback to HandleCollectionMediaL

    iCollectionUtility->Collection().MediaL( *mediaPath, attrs.Array() );

    CleanupStack::PopAndDestroy( &attrs );

    CleanupStack::PopAndDestroy( mediaPath );

    // Wait until signalled to proceed

    iWait->Start();

    if( iStatus != KErrNone )

        {

        if( iStatus == KErrNotFound )

            {

            // Album is empty

            __LOG( "ListAlbumsL: Album is empty" );

            return;

            }

        else // Some other problem

            {

            User::Leave( iStatus );

            }

        }

    if ( iMedia != 0 )

        {

        __LOG( "CUPnPAlbumServices::iMedia exist! ");

        TMPXAttribute mediaArrayAttr( KMPXMediaIdContainer,

            EMPXMediaArrayContents );

        // Check if there is more than one item in album

        if( iMedia->IsSupported( mediaArrayAttr ) )

            {

            __LOG("getting album array");

            CMPXMediaArray* medias = iMedia->ValueCObjectL<CMPXMediaArray>(

                mediaArrayAttr );

            if( medias )

                {

                __LOG( "CUPnPAlbumServices::album array exist! ");

                CleanupStack::PushL( medias );

                // Album count

                TInt count = medias->Count();        

                __LOG1( "Album count=%d", count );

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

                    {

                    __LOG2( "accessing album: item %d of %d",i, count );

                    const CMPXMedia* entry = (*medias)[i];

                    const TDesC& uri = entry->ValueText(

                        KMPXMediaGeneralUri );

                    __LOG1( "Item uri:[%S]", &uri );

                    aContentMedia.AppendL( entry->ValueText(

                        KMPXMediaGeneralUri ) );

                    }

                 CleanupStack::PopAndDestroy( medias );

                 }

            }

         else // Handle single item

            {

            __LOG("getting single item");

            const TDesC& uri = iMedia->ValueText( KMPXMediaGeneralUri );

            __LOG1( "Item uri:[%S]", &uri );

            aContentMedia.AppendL( iMedia->ValueText( KMPXMediaGeneralUri ) );

            }

        delete iMedia;

        iMedia = 0;

        }

    __LOG( "CUPnPAlbumServices::OpenAlbumL - End ");

    }

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

// CUPnPAlbumServices::IsValidAlbumL

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

//

EXPORT_C TBool CUPnPAlbumServices::IsValidAlbumL(

    const TDesC& aAlbumName )

    {

    TBool found = EFalse;

    __LOG1( "IsValidAlbumL(%S)", &aAlbumName );

    if( iStatus != KErrNone)

        {

        __LOG1( "CUPnPAlbumServices::IsValidAlbumL iStatus %d return", iStatus );

        return EFalse;

        }

    // Check if already listed

    if( iAlbumNames->Count() > 0 )

        {

        __LOG( "CUPnPAlbumServices::IsValidAlbumL: Already fetched." );

        TInt count = iAlbumNames->Count();

        __LOG1( "Album count=%d", count );

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

            {

            if( aAlbumName.Compare( iAlbumNames->MdcaPoint(i) ) == 0 )

                {

                __LOG( "IsValidAlbum -> True ");

                i = count;

                found = ETrue;

                }

            }

        __LOG( "CUPnPAlbumServices::IsValidAlbumL: Return." );

        return found;

        }

    // List albums

    CMPXCollectionPath* mediaPath = iCollectionUtility->Collection().PathL();

    CleanupStack::PushL( mediaPath );

    mediaPath->SelectAllL();

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    attrs.Append( KMPXMediaGeneralId );

    attrs.Append( KMPXMediaGeneralTitle );

    // Get album data. Callback to HandleCollectionMediaL

    iCollectionUtility->Collection().MediaL( *mediaPath, attrs.Array() );

    CleanupStack::PopAndDestroy( &attrs );

    CleanupStack::PopAndDestroy( mediaPath );

    // Wait until signalled to proceed

    iWait->Start();

    if( iStatus != KErrNone )

        {

        if( iStatus == KErrNotFound )

            {

            // No albums available

            __LOG( "ListAlbumsL: No albums available" );

            return EFalse;

            }

        else // Some other problem

            {

            User::Leave( iStatus );

            }

        }

    if ( iMedia != 0 )

        {

        __LOG( "CUPnPAlbumServices::iMedia exist! ");

        TMPXAttribute mediaArrayAttr( KMPXMediaIdContainer,

            EMPXMediaArrayContents );

        if( iMedia->IsSupported( mediaArrayAttr ) )

            {

            __LOG("getting album array");

            CMPXMediaArray* medias = iMedia->ValueCObjectL<CMPXMediaArray>(

                mediaArrayAttr );

            if( medias )

                {

                __LOG( "CUPnPAlbumServices::album array exist! ");

                CleanupStack::PushL( medias );

                // Album count

                TInt count = medias->Count();        

                __LOG1( "Album count=%d", count );

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

                    {

                    const CMPXMedia* entry = (*medias)[i];

                    if( aAlbumName.Compare( 

                        entry->ValueText( KMPXMediaGeneralTitle ) ) == 0 )

                        {

                        __LOG( "IsValidAlbum -> True ");

                        found = ETrue;

                        break;

                        }

                    }

                CleanupStack::PopAndDestroy( medias );

                }

            }

        else

            {

            __LOG( "iMedia->IsSupported = False!" );

            }

        delete iMedia;

        iMedia = 0;

        }

    __LOG( "CUPnPAlbumServices::IsValidAlbumL - End ");

    return found;

    }

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

// CUPnPAlbumServices::~CUPnPAlbumServices

// Destructor.

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

//

EXPORT_C CUPnPAlbumServices::~CUPnPAlbumServices()

    {

    __LOG( "CUPnPAlbumServices::~CUPnPAlbumServices" );

    iAlbumNames->Reset();

    delete iAlbumNames;

    iAlbumNames = 0;

    iAlbumIds->Reset();

    delete iAlbumIds;

    iAlbumIds = 0;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        iCollectionUtility = 0;

        }

    delete iWait;

    iWait = 0;

    if( iMedia )

        {

        delete iMedia;

        iMedia = 0;

        }

    }

// Methods from MMPXCollectionObserver:

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

// CUPnPAlbumServices::HandleCollectionMessage

// Callback for Collection->OpenL()

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

// 

void CUPnPAlbumServices::HandleCollectionMessage( CMPXMessage* aMsg,

    TInt aErr )

    {

    __LOG1( "HandleCollectionMessage: err=%d", aErr );

	if( aErr == KErrNone)

	    {

	    TRAPD( error, DoHandleCollectionMessageL( aMsg ) );

        if ( error != KErrNone )

            {

            __LOG1( "DoHandleCollectionMessageL: leave with %d", error );

            iStatus = error;

            iWait->AsyncStop();

            }

	    }

	 else

	    {

	    iStatus = aErr;

	    iWait->AsyncStop();

	    }

    }

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

// CUPnPAlbumServices::HandleCollectionMediaL

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

//

void CUPnPAlbumServices::HandleCollectionMediaL( const CMPXMedia& aMedia,

    TInt aError )

    {

    __LOG1( "CUPnPAlbumServices::HandleCollectionMediaL: err=%d", aError );

    if( aError == KErrNone )

        {                    

        // delete if already exist

        if( iMedia )

            {

            delete iMedia;

            iMedia = 0;

            }

        iMedia = CMPXMedia::NewL( aMedia );

        }

    iStatus = aError;

    iWait->AsyncStop();

    __LOG("CUPnPAlbumServices::HandleCollectionMediaL - End");

    }