/*

* 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:  Base class for filling an MPX playlist

*

*/

// INCLUDES

// System

#include <escapeutils.h> // for unicode conversion

// upnp utility 

#include "upnpitemutility.h"

// upnp stack api

#include <upnpobject.h>

// XML framework api

#include <mpxcollectionplaylist.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

// upnpframework / avcontroller api

#include "upnpavdevice.h" // for the device

// upnpframeowrk / avcotnroller helper api

#include "upnpconstantdefs.h" // for KClassAudio

// musicadapter internal

#include "upnpmusicadapter.h" // for Complete(this)

#include "upnpplaylistfiller.h"

// debug

_LIT16( KComponentLogfile, "musicadapter.txt" );

#include "upnplog.h"

// CONSTANTS

_LIT16( KUPnPPrefix, "upnp:" );

_LIT16( KSeparator, "*" );

const TInt KMaxElementSize = 256; // from UPNP/DLNA

const TInt KItemListGranularity = 20;

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

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

// CUPnPPlayListFiller::NewL

// 1st phase constructor.

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

//

EXPORT_C CUPnPPlayListFiller* CUPnPPlayListFiller::NewL()

    {

    CUPnPPlayListFiller* self = new(ELeave)

        CUPnPPlayListFiller();

    return self;

    }

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

// CUPnPPlayListFiller::CUPnPPlayListFiller

// Default constructor.

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

//    

CUPnPPlayListFiller::CUPnPPlayListFiller()

    : iItemList( KItemListGranularity )

    {

    iSelectedIndex = 0;

    }

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

// CUPnPPlayListFiller::~CUPnPPlayListFiller

// Destructor.

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

//

EXPORT_C CUPnPPlayListFiller::~CUPnPPlayListFiller()

    {

    __LOG( "CUPnPPlayListFiller::~CUPnPPlayListFiller" );

    iItemList.Reset();

    delete iDeviceUid;

    }

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

// CUPnPPlayListFiller::InsertObjectL

// Fill track data into the playlist

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

//

EXPORT_C void CUPnPPlayListFiller::InsertObjectL(

    const CUpnpAVDevice& aMediaServer,

    const CUpnpObject& aObject )

    {

    if ( !iSourceDevice )

        {

        iSourceDevice = &aMediaServer;        

        iDeviceUid = HBufC::NewL( aMediaServer.Uuid().Length() );

        iDeviceUid->Des().Copy( aMediaServer.Uuid() );

        }

    else

        {

        // we only support playlists from a single device.

        __ASSERTD( &aMediaServer == iSourceDevice , __FILE__, __LINE__ );

        }

    iItemList.AppendL( &aObject );

    }

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

// CUPnPPlayListFiller::SetSelectedIndex

// Sets the index of pre-selected item

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

//

EXPORT_C void CUPnPPlayListFiller::SetSelectedIndex(

    TInt aSelectedIndex )

    {

    __ASSERTD( aSelectedIndex >= 0, __FILE__, __LINE__ );

    __ASSERTD( aSelectedIndex < iItemList.Count(), __FILE__, __LINE__ );

    iSelectedIndex = aSelectedIndex;

    }

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

// CUPnPPlayListFiller::FillL

// Fill track data into the playlist

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

//

void CUPnPPlayListFiller::FillL(

    CUPnPMusicAdapter& aHost,

    CMPXMediaArray& aPlaylist )

    {

    __LOG( "CUPnPPlayListFiller::FillL" );

    SetHost( aHost );

    DoFillL( aPlaylist, iItemList );

    DoComplete();

    }

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

// CUPnPPlayListFiller::CancelFill

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

//

void CUPnPPlayListFiller::CancelFill()

    {

    // no implementation required

    // - this class does not have async nature

    }

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

// CUPnPPlayListFiller::PlaylistSize

// Returns the total playlist size

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

//

TInt CUPnPPlayListFiller::PlaylistSize()

    {

    return iItemList.Count();

    }

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

// CUPnPPlayListFiller::ObjectArray

// returns a non-modifiable reference of the object list

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

//

const RPointerArray<CUpnpObject>& CUPnPPlayListFiller::ObjectArray()

    {

    return iItemList;

    }

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

// CUPnPPlayListFiller::SourceDevice

// returnsthe media server the playlist is located

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

//

const CUpnpAVDevice& CUPnPPlayListFiller::SourceDevice()

    {

    return *iSourceDevice;

    }

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

// CUPnPPlayListFiller::SetHost

// Assigns the host music adapter

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

//

void CUPnPPlayListFiller::SetHost( CUPnPMusicAdapter& aHost )

    {

    iHost = &aHost;

    }

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

// CUPnPPlayListFiller::Host

// returns the host music adapter

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

//

CUPnPMusicAdapter& CUPnPPlayListFiller::Host() const

    {

    __ASSERTD( iHost != 0 , __FILE__, __LINE__ );

    return *iHost;

    }

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

// CUPnPPlayListFiller::SelectedIndex

// Index of selected item

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

//

TInt CUPnPPlayListFiller::SelectedIndex() const

    {

    return iSelectedIndex;

    }

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

// CUPnPPlayListFiller::DoFillL

// Fill track data into the playlist - base class implementation

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

//

TInt CUPnPPlayListFiller::DoFillL( CMPXMediaArray& aPlaylist,

    const RPointerArray<CUpnpObject>& aSource, TInt /*aStartIndex*/ )

    {

    __LOG( "CUPnPPlayListFiller::DoFillL" );

    // Add currently cached items to the playlist

    TInt i = 0;

    for( ; i < aSource.Count() ; ++i )

        {

        DoFillObjectL( aPlaylist, *aSource[i], i );

        }

    __LOG( "CUPnPPlayListFiller::DoFillL - end" );

    return i;

    }

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

// CUPnPPlayListFiller::DoFillObjectL

// Fills a ingle object to a playlist

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

//

void CUPnPPlayListFiller::DoFillObjectL(  CMPXMediaArray& aPlaylist,

    const CUpnpObject& aObject, TInt /*aIndex*/ )

    {

    // Create new media object for track

    CMPXMedia* media = CMPXMedia::NewL();

    CleanupStack::PushL( media );

    // Set type

    media->SetTObjectValueL<TMPXGeneralType>( 

        KMPXMediaGeneralType, EMPXItem );

    // Set gategory

    media->SetTObjectValueL<TMPXGeneralCategory>( 

        KMPXMediaGeneralCategory, EMPXSong );

    // URI

    if( UPnPItemUtility::BelongsToClass( aObject , KClassAudio ) )

        {

        ConvertToURI( *iDeviceUid, aObject, iTempBuf );

        }

    else // item is non audio set uri to KUPnPPrefix

    	{

    	iTempBuf.Copy( KUPnPPrefix );

    	}

    media->SetTextValueL( 

        KMPXMediaGeneralUri, iTempBuf );

    // Title

    HBufC16* buf = 

        EscapeUtils::ConvertToUnicodeFromUtf8L( aObject.Title() );

    CleanupStack::PushL( buf );

    media->SetTextValueL( 

        KMPXMediaGeneralTitle, *buf );

    CleanupStack::PopAndDestroy( buf );

    // Add track to the object list

    aPlaylist.AppendL( media );

    CleanupStack::Pop( media );

    }

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

// CUPnPPlayListFiller::DoComplete

// Completes the object, causing it to be destroyed.

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

//

void CUPnPPlayListFiller::DoComplete()

    {

    Host().Complete( this );

    }

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

// CUPnPPlayListFiller::ConvertToURI

// Convert UPnP item to playlist item URI string

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

//  

void CUPnPPlayListFiller::ConvertToURI( const TDesC& aDeviceUid,

    const CUpnpObject& aItem, TDes& aBuffer )

    {

    // Start with upnp prefix

    aBuffer.Copy( KUPnPPrefix );

    aBuffer.Append( aDeviceUid );

    aBuffer.Append( KSeparator );

    // add object id (converting 8->16 bit)

    TBuf<KMaxElementSize> id16;

    id16.Copy( aItem.Id() );

    aBuffer.Append( id16 );

    }