/*
* Copyright (c) 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 services for filling MPX playlist
*
*/


// INCLUDE FILES
// System
#include <escapeutils.h> // for unicode conversion
#include <escapeutils.h> // for unicode conversion

// XML framework api
#include <mpxcollectionplaylist.h>
#include <mpxmediaarray.h>
#include <mpxmediageneraldefs.h>

// upnpframework / avcontroller api
#include "upnpavdevice.h" // for the device

// upnpframework / avcontroller helper api
#include "upnpconstantdefs.h" // for KClassAudio

// upnpframework / xmlparser api
#include "upnpobjectlite.h"

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

// debug
_LIT16( KComponentLogfile, "musicadapter.txt" );
#include "upnplog.h"

// CONSTANTS
_LIT16( KUPnPPrefix, "upnp:" );
_LIT16( KSeparator, "*" );
const TInt KMaxElementSize = 256; // from UPNP/DLNA

// METHODS

// --------------------------------------------------------------------------
// CUPnPLiteFiller::NewL
//---------------------------------------------------------------------------
CUPnPLiteFiller* CUPnPLiteFiller::NewL()
    {
    CUPnPLiteFiller* filler = 
        new(ELeave)CUPnPLiteFiller();
    CleanupStack::PushL( filler );
    filler->ConstructL();
    CleanupStack::Pop( filler );
    return filler;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::SetSelectedIndex
// Sets the index of pre-selected item
// --------------------------------------------------------------------------
//
EXPORT_C void CUPnPLiteFiller::SetSelectedIndex(
    TInt aSelectedIndex )
    {
    __ASSERTD( aSelectedIndex >= 0, __FILE__, __LINE__ );
    iSelectedIndex = aSelectedIndex;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::SetSourceDeviceL
// Set the media server the playlist is located
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::SetSourceDeviceL( const CUpnpAVDevice& aDevice )
    {
    if ( !iSourceDevice )
        {
        iSourceDevice = &aDevice;        
        iDeviceUid = HBufC::NewL( aDevice.Uuid().Length() );
        iDeviceUid->Des().Copy( aDevice.Uuid() );
        }
    else
        {
        // we only support playlists from a single device.
        __ASSERTD( &aDevice == iSourceDevice , __FILE__, __LINE__ );
        }
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::SetHost
// Assigns the host music adapter
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::SetHost( CUPnPMusicAdapter& aHost )
    {
    iHost = &aHost;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::Host
// returns the host music adapter
// --------------------------------------------------------------------------
//
CUPnPMusicAdapter& CUPnPLiteFiller::Host() const
    {
    __ASSERTD( iHost != 0 , __FILE__, __LINE__ );
    return *iHost;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::DoComplete
// Completes the object, causing it to be destroyed.
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::DoComplete()
    {
    Host().Complete( this );
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::FillL
// Fill track data into the playlist
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::FillL(
    CUPnPMusicAdapter& /*aHost*/,
    CMPXMediaArray& /*aPlaylist*/ )
    {
    // no implementation required
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::CancelFill
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::CancelFill()
    {
    // no implementation required
    // - this class does not have async nature
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::PlaylistSize
// Returns the total playlist size
// --------------------------------------------------------------------------
//
TInt CUPnPLiteFiller::PlaylistSize()
    {
    // no implementation required
    return 0;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::SelectedIndex
// Index of selected item
// --------------------------------------------------------------------------
//
TInt CUPnPLiteFiller::SelectedIndex() const
    {
    return iSelectedIndex;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::~CUPnPLiteFiller
//---------------------------------------------------------------------------
EXPORT_C CUPnPLiteFiller::~CUPnPLiteFiller()
    {
    delete iDeviceUid;
    iDeviceUid = 0;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::FillItemMpxPlaylistL
// Fills a single item to mpx playlist
// --------------------------------------------------------------------------
//
void CUPnPLiteFiller::FillItemMpxPlaylistL(  CMPXMediaArray& aPlaylist,
    const CUpnpObjectLite& aItem, 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( aItem.IsTypeOf( CUpnpObjectLite::EMusicItem ) )
        {
        ConvertToURI( *iDeviceUid, aItem, iTempBuf );
        }
    else // item is non audio set uri to zero
        {
        iTempBuf.Zero();
        }
    media->SetTextValueL( 
        KMPXMediaGeneralUri, iTempBuf );
    // Title        
    media->SetTextValueL( 
        KMPXMediaGeneralTitle, aItem.Title() );
    // Add track to the object list
    aPlaylist.AppendL( media );
    CleanupStack::Pop( media );
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::CUPnPLiteFiller
// 1st phase constructor.
// --------------------------------------------------------------------------
//
CUPnPLiteFiller::CUPnPLiteFiller()
    {
    iSelectedIndex = 0;
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::ConstructL
// 2nd phase constructor.
// --------------------------------------------------------------------------
// 
void CUPnPLiteFiller::ConstructL()
    {
    // None.
    }

// --------------------------------------------------------------------------
// CUPnPLiteFiller::ConvertToURI
// Convert UPnP item to playlist item URI string
// --------------------------------------------------------------------------
//  
void CUPnPLiteFiller::ConvertToURI( const TDesC& aDeviceUid,
    const CUpnpObjectLite& 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.ObjectId() );
    aBuffer.Append( id16 );
    }