/*

* 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:  Fills MPX playlist by browsing media server content

*

*/

// INCLUDE FILES

// upnp stack api

#include <upnpobject.h>

// MPX framework api

#include <mpxcollectionutility.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

// upnpframework / avcontroller api

#include "upnpavcontroller.h"

#include "upnpavdevice.h"

#include "upnpavbrowsingsession.h"

// upnpframework / avcontroller helper api

#include "upnpconstantdefs.h" // for browse filters

// upnpframework / xmlparser api

#include "upnpxmlparser.h"

// musicadapter internal

#include "upnpmusicadapter.h"

#include "upnpbrowseplaylistfiller.h"

// debug

_LIT16( KComponentLogfile, "musicadapter.txt" );

#include "upnplog.h"

// CONSTANTS

const TInt KBrowseRequestedCount = 100;

const TUid KHostAppUid = { 0x10208A0A };  // Host app UID

const TInt KMaxPlaylistSize = 500; // MAX container size to play

const TInt KBrowsePeriod = 5000000; // 5 seconds

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

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

// CUPnPBrowsePlaylistFiller::NewL

// static constructor.

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

//

EXPORT_C CUPnPBrowsePlaylistFiller* CUPnPBrowsePlaylistFiller::NewL( 

    const TDesC8& aContainerId,

    TInt aCachedStartIndex,

    TInt aTotalContainerSize )

    {

    __LOG( "CUPnPBrowsePlaylistFiller::NewL" );

    CUPnPBrowsePlaylistFiller* self = new(ELeave)

        CUPnPBrowsePlaylistFiller();

    CleanupStack::PushL( self );

    self->ConstructL( aContainerId, aCachedStartIndex, aTotalContainerSize );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPBrowsePlaylistFiller::CUPnPBrowsePlaylistFiller

// 1st phase constructor.

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

//

CUPnPBrowsePlaylistFiller::CUPnPBrowsePlaylistFiller()

    : CUPnPPlayListFiller()

    {

    }

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

// CUPnPBrowsePlaylistFiller::ConstructL

// 2nd phase constructor.

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

// 

void CUPnPBrowsePlaylistFiller::ConstructL(

    const TDesC8& aContainerId,

    TInt aCachedStartIndex,

    TInt aTotalContainerSize )

    {

    // Create timer for continue browse after short period.

    iBrowseTimer = CUPnPBrowseTimer::NewL( *this, KBrowsePeriod );

    iBlocksize = KBrowseRequestedCount;

    iContainerId = HBufC8::NewL( aContainerId.Length() );

    iContainerId->Des().Copy( aContainerId );    

    iCachedStartIndex = aCachedStartIndex;

    iPlaylistInitialSize = KErrUnknown;

    if ( aTotalContainerSize >= 0 )

        {

        iPlaylistInitialSize = Min(

            aTotalContainerSize - iCachedStartIndex,

            KMaxPlaylistSize );

        }

    iPlaylistActualSize = 0;

    }

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

// CUPnPBrowsePlaylistFiller::~CUPnPBrowsePlaylistFiller

// Destructor.

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

//

EXPORT_C CUPnPBrowsePlaylistFiller::~CUPnPBrowsePlaylistFiller()

    {

    delete iBrowseTimer;

    iBrowseTimer = 0;

    __LOG( "CUPnPBrowsePlaylistFiller::~CUPnPBrowsePlaylistFiller" );

    if ( iBrowsingSession )

        {

        Host().AVController().StopBrowsingSession( *iBrowsingSession );

        iBrowsingSession = 0;

        }

    delete iContainerId;

    }

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

// CUPnPBrowsePlaylistFiller::FillL

// Fill track data into the playlist and continue browsing

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

//    

void CUPnPBrowsePlaylistFiller::FillL(

    CUPnPMusicAdapter& aHost,

    CMPXMediaArray& aPlaylist )

    {

    __LOG( "CUPnPBrowsePlaylistFiller::Fill" );

    SetHost( aHost );

    // fill the initial items, increase the index

    iCurrentIndex = iCachedStartIndex;

    iPlaylistActualSize = DoFillL( aPlaylist, ObjectArray() );

    iCurrentIndex += ObjectArray().Count();

    if ( iPlaylistActualSize < iPlaylistInitialSize )

        {

        // Start doing more browse requests after short waiting period

        iBrowseTimer->Start();

        }

    else

        {

        __LOG( "CUPnPBrowsePlaylistFiller::Fill - \

        No need to browse" );

        DoComplete();

        }

    }

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

// CUPnPBrowsePlaylistFiller::CancelFill

// Fill track data into the playlist and continue browsing

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

//    

void CUPnPBrowsePlaylistFiller::CancelFill()

    {

    if ( iBrowsingSession )

        {

        iBrowsingSession->CancelBrowse();

        }

    }

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

// CUPnPPlayListFiller::PlaylistSize

// Returns the total playlist size

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

//

TInt CUPnPBrowsePlaylistFiller::PlaylistSize()

    {

    if ( iPlaylistInitialSize >= 0 )

        {

        return iPlaylistInitialSize;

        }

    else

        {

        return ObjectArray().Count();

        }

    }

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

// Methods from MUPnPAVBrowsingSessionObserver

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

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

// CUPnPBrowsePlaylistFiller::BrowseResponse

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

// 

void CUPnPBrowsePlaylistFiller::BrowseResponse(

    const TDesC8& aBrowseResponse, TInt aError, TInt /*aMatches*/,

    TInt aTotalCount, const TDesC8& /*aUpdateId*/ )

    {

    __LOG( "CUPnPBrowsePlaylistFiller::BrowseResponse" );

    TBool continueBrowse = ETrue;

    // Stop browsing if any error in previous browse 

    if( aError != KErrNone )

        {

        // Browse stops to an error - do not continue playlist.

        __LOG( "CUPnPBrowsePlaylistFiller::BrowseResponse ->error!" );

        continueBrowse = EFalse;

        DoComplete();

        }

    else 

        {

        __LOG( "CUPnPBrowsePlaylistFiller::BrowseResponse - \

            Error None" );

        TInt error = KErrNone;

        TRAP( error, AddMediaToCollectionL( aBrowseResponse ) );

        if( error != KErrNone )

            {

            __LOG( "CUPnPBrowsePlaylistFiller::BrowseResponse - \

            AddMediaToCollectionL leaves!" );

            continueBrowse = EFalse;

            DoComplete();

            }

        else

            {

            if ( iPlaylistActualSize >= iPlaylistInitialSize )

                {

                // browse is complete

                __LOG( "CUPnPBrowsePlaylistFiller::BrowseResult - \

                    ->playlist size reached." );

                continueBrowse = EFalse;

                DoComplete();

                }

            if ( iCurrentIndex >= aTotalCount )

                {

                // browse is complete

                __LOG( "CUPnPBrowsePlaylistFiller::BrowseResult - \

                    ->end of data." );

                continueBrowse = EFalse;

                DoComplete();

                }

            }     

        }

    if ( continueBrowse )

        {

        // Calculate item count to be browsed.

        iBlocksize = KBrowseRequestedCount;

        if ( iPlaylistActualSize + iBlocksize > iPlaylistInitialSize )

            {

            iBlocksize = iPlaylistInitialSize - iPlaylistActualSize;

            }

        // Continue the browse request            

        iBrowseTimer->Continue();

        }

    }

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

// CUPnPBrowsePlaylistFiller::AddMediaToCollectionL

// Adds media to collection

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

//    

void CUPnPBrowsePlaylistFiller::AddMediaToCollectionL( 

    const TDesC8& aBrowseResponse )

    {

    CUPnPXMLParser* parser = NULL;

    parser = CUPnPXMLParser::NewL();

    CleanupStack::PushL( parser );

    RPointerArray<CUpnpObject> array;

    parser->ParseResultDataL( array, aBrowseResponse );

    // Update playlist counter

    iCurrentIndex += KBrowseRequestedCount;

    TInt count = array.Count();    

    if( count > 0 )

        {

        // Create new media object

        CMPXMedia* media = CMPXMedia::NewL(); 

        CleanupStack::PushL( media );

        // Set collection Uid

        media->SetTObjectValueL<TUid>( 

        KMPXMediaGeneralCollectionId,

        Host().PlaylistCollectionId() );

        // Set type

        media->SetTObjectValueL<TMPXGeneralType>( 

        KMPXMediaGeneralType, EMPXItem );

        // Set category

        media->SetTObjectValueL<TMPXGeneralCategory>( 

        KMPXMediaGeneralCategory, EMPXPlaylist );

        // Set playlist ID

        media->SetTObjectValueL<TMPXItemId>(

        KMPXMediaGeneralId, KHostAppUid.iUid );

        // Add playlist into media object

        CMPXMediaArray* playlist = CMPXMediaArray::NewL();

        CleanupStack::PushL( playlist ); 

        iPlaylistActualSize += DoFillL( *playlist, array );

        media->SetCObjectValueL( 

        KMPXMediaArrayContents, playlist );

        // Add count of items in playlist

        media->SetTObjectValueL( 

        KMPXMediaArrayCount,

        playlist->Count() );

        CleanupStack::PopAndDestroy( playlist );

        __LOG( "CUPnPBrowsePlaylistFiller::AddMediaToCollectionL - \

        Collection->SetSyncL" );

        // Add new playlist to the collection

        Host().CollectionUtility().Collection().SetSyncL( *media );

        CleanupStack::PopAndDestroy( media );

        }

    else

        {

        __LOG( "CUPnPBrowsePlaylistFiller::AddMediaToCollectionL - \

        No items received!" );

        User::Leave( KErrNotFound );

        }

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( parser );

    }

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

// CUPnPBrowsePlaylistFiller::MediaServerDisappeared

// The media server has vanished

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

//    

void CUPnPBrowsePlaylistFiller::MediaServerDisappeared( 

    TUPnPDeviceDisconnectedReason /*aReason*/ )

    {

    __LOG( "CUPnPBrowsePlaylistFiller::MediaServerDisappeared" );

    DoComplete();

    }

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

// Unused callback methods from the interface

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

//    

void CUPnPBrowsePlaylistFiller::SearchResponse( 

    const TDesC8& /*aSearchResponse*/, TInt /*aError*/, TInt /*aMatches*/,

    TInt /*aTotalCount*/, const TDesC8& /*aUpdateId*/ ) {}

void CUPnPBrowsePlaylistFiller::SearchCapabilitiesResponse( TInt /*aError*/,

    const TDesC8& /*aSearchCapabilities*/ ) {}

void CUPnPBrowsePlaylistFiller::CreateContainerResponse( TInt /*aError*/, 

    const TDesC8& /*aObjectId*/ ) {}

void CUPnPBrowsePlaylistFiller::DeleteObjectResponse( TInt /*aError*/ ) {}

void CUPnPBrowsePlaylistFiller::ReserveLocalMSServicesCompleted( TInt 

    /*aError*/ ) {}

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

// CUPnPBrowsePlaylistFiller::HandlePeriod

// Action when timer has expired.

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

// 

void CUPnPBrowsePlaylistFiller::HandlePeriod()

    {

    __LOG( "CUPnPBrowsePlaylistFiller::HandlePeriod" );

    TRAP_IGNORE( 

    // start a browsing session if not already started

    if( iBrowsingSession == 0 )

        {

        __LOG( "Start a browsing session" );

        iBrowsingSession = &Host().AVController()

            .StartBrowsingSessionL( SourceDevice() );

        iBrowsingSession->SetObserver( *this );

        }

    __LOG( "Start doing more browse requests" );

    // Start doing more browse requests

    iBrowsingSession->BrowseL( *iContainerId, KFilterMin,

        MUPnPAVBrowsingSession::EDirectChildren, iCurrentIndex,

        iBlocksize, KSortNone );

        );

    }