/*

* Copyright (c) 2008 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:  AV Controller UPnP actions handler

*

*/

#include "upnpavdevice.h"

#include "upnpxmlparser.h"

#include "upnpavcontroller.h"

#include "upnpavbrowsingsession.h"

#include "upnpconstantdefs.h"

#include "upnpitem.h"

#include <w32std.h>

#include "upnpitemutility.h"

#include "cmfilllistitem.h"

#include "cmfmupnpactionobserver.h"

#include "cmfmupnpmngr.h"

#include "msdebug.h"

_LIT8( KCmBrowseFilter,    "*" ); // No filter

_LIT8( KCmSortCriteria,    "" ); // No sorting

const TInt KStartIndex = 0; // Start from beginning

const TInt KRequestedCount = 1; // Only one item browsed at a time

const TInt KScreenWidth = 128;

const TInt KScreenHeight = 128;

_LIT8( KCmFmXMark, "x" );

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

// CCmFmUpnpMngr::NewL

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

//

CCmFmUpnpMngr* CCmFmUpnpMngr::NewL( MCmFmUPnPActionObserver* aObserver )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::NewL() start"));    

    CCmFmUpnpMngr* self = CCmFmUpnpMngr::NewLC( aObserver );

    CleanupStack::Pop( self );

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::NewL() end"));

    return self;

    }

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

// CCmFmUpnpMngr::NewLC

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

//   

CCmFmUpnpMngr* CCmFmUpnpMngr::NewLC( MCmFmUPnPActionObserver* aObserver )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::NewLC() start"));    

    CCmFmUpnpMngr* self = new ( ELeave ) CCmFmUpnpMngr( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::NewLC() end"));

    return self;  

    }    

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

// CCmFmUpnpMngr::~CCmFmUpnpMngr

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

//

CCmFmUpnpMngr::~CCmFmUpnpMngr()

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::~CCmFmUpnpMngr()"));

    CancelOperation();

    delete iURI;

    delete iParser;

    delete iItem;

    }

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

// CCmFmUpnpMngr::CCmFmUpnpMngr

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

//        

CCmFmUpnpMngr::CCmFmUpnpMngr( MCmFmUPnPActionObserver* aObserver )

    : iObserver( aObserver ), iScreenSize( KScreenWidth, KScreenHeight )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::CCmFmUpnpMngr()"));

    }

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

// CCmFmUpnpMngr::ConstructL

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

// 

void CCmFmUpnpMngr::ConstructL()

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::ConstructL()"));

    iParser = CUPnPXMLParser::NewL();

    ScreenSizeL();

    TRACE(Print(_L("[FILL MNGR]\t Phones screen size = %d x %d"), 

        iScreenSize.iWidth, iScreenSize.iHeight ));

    }    

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

// CCmFmUpnpMngr::SetAvController

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

// 

void CCmFmUpnpMngr::SetAvController( MUPnPAVController* aAVController )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::SetAvController()"));

    if( aAVController )

        {

        aAVController->SetDeviceObserver( *this );

        }    

    iAVController = aAVController;

    iBrowseSession = NULL;

    delete iURI;

    iURI = NULL;

    delete iItem;

    iItem = NULL;       

    }

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

// CCmFmUpnpMngr::GetMediaServersL

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

//     

void CCmFmUpnpMngr::GetMediaServersL( CUpnpAVDeviceList*& aDevices )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::GetMediaServersL()"));

    if( iAVController )

        {

        aDevices = iAVController->GetMediaServersL();

        }

    }

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

// CCmFmUpnpMngr::CheckURIL

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

//     

void CCmFmUpnpMngr::CheckURIL( CUpnpAVDevice* aDevice,

                               CCmFillListItem& aItem )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::CheckURIL()"));

    if( iAVController )

        {

        iSelectOptimalImageSize = EFalse;

        if( aItem.Status() == ECmToBeShrinked )

            {

            iSelectOptimalImageSize = ETrue;

            }

	    if( !iBrowseSession )

			{

            // session not found -> create

            iBrowseSession =

                &iAVController->StartBrowsingSessionL( *aDevice );

            iBrowseSession->SetObserver( *this );   

			iDevice = aDevice;

			}	

        else if( ( aDevice != iDevice ) ||

	        ( aDevice->Uuid() != iDevice->Uuid() ) )

			{

            // device is different than previosly or pointer to it

            // has been changed -> create new session

			CancelOperation();           

			iBrowseSession =

				&iAVController->StartBrowsingSessionL( *aDevice );

			iBrowseSession->SetObserver( *this );  

			iDevice = aDevice;    

			}

        iBrowseSession->BrowseL( aItem.ItemId(), KCmBrowseFilter, 

            MUPnPAVBrowsingSession::EMetadata, KStartIndex, 

            KRequestedCount, KCmSortCriteria );

        iBrowseStarted.HomeTime();

        TRACE(Print(_L("[FILL MNGR]\t BROWSE STARTED")));

#ifdef _DEBUG

        TBuf<KMaxName> temp;

        if( aDevice->Uuid().Length() < KMaxName )

            {

            temp.Copy( aDevice->Uuid() );

            TRACE(Print(_L("[FILL MNGR]\t TARGET DEVICE %S"), &temp ));

            }

        temp.Zero();

        if( aItem.ItemId().Length() < KMaxName )

            {

            temp.Copy( aItem.ItemId() );

            TRACE(Print(_L("[FILL MNGR]\t TARGET ITEM %S"), &temp ));        

            }

        temp.Zero();       

#endif         

        }

    else

        {

        TRACE(Print(_L("[FILL MNGR]\t iAVController == NULL"))); 

        iObserver->URICheckResult( ENoUriAvailable );

        }        

    }

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

// CCmFmUpnpMngr::CancelOperation

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

//     

void CCmFmUpnpMngr::CancelOperation()

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::CancelOperation()"));

    if( iBrowseSession )

        {

        iAVController->StopBrowsingSession( *iBrowseSession );

		iBrowseSession = NULL;

        }        

    }

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

// CCmFmUpnpMngr::Uri

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

// 

TDesC8& CCmFmUpnpMngr::Uri() const

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::Uri()"));

    return *iURI;

    }

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

// CCmFmUpnpMngr::UpnpItem

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

// 

CUpnpItem& CCmFmUpnpMngr::UpnpItem() const

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::UpnpItem()"));

    return *iItem;

    }

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

// CCmFmUpnpMngr::BrowseResponse

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

// 

void CCmFmUpnpMngr::BrowseResponse(

                    const TDesC8& aBrowseResponse,

                    TInt aError,

                    TInt /*aMatches*/,

                    TInt aTotalCount,

                    const TDesC8& /*aUpdateId*/

                    )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::BrowseResponse()"));   

    TRACE(Print(_L("[FILL MNGR]\t ParseResultDataL error = %d"), aError ));

    TRAPD( err, BrowseResponseL( aError, aTotalCount, aBrowseResponse ) );

    if ( err )

        {

        TRACE(Print(_L("[FILL MNGR]\t BrowseResponseL err = %d"), err ));

        }    

    }

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

// CCmFmUpnpMngr::BrowseResponseL

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

//    

void CCmFmUpnpMngr::BrowseResponseL( TInt aStatus,

                                     TInt /*aTotalCount*/,

                                     const TDesC8& aResultArray )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::BrowseResponseL()"));

    RPointerArray<CUpnpObject> tempArray;

    CleanupClosePushL( tempArray );

    TInt err( aStatus );

    TRACE(Print(_L("[FILL MNGR]\t BrowseResponse err = %d"), err )); 

    if( !err )

        {

        TRAP( err, iParser->ParseResultDataL(

            tempArray, aResultArray ) );        

        }

    /** Browse finished */

    iBrowseFinished.HomeTime();

    TTimeIntervalMicroSeconds usecsFrom = 

        iBrowseFinished.MicroSecondsFrom( iBrowseStarted );

    TRACE(Print(_L("[FILL MNGR]\t Browse took = %ld microseconds"), 

        usecsFrom.Int64() ));

    if( !err )

        {

    	if ( tempArray.Count() )

    		{

    		if( iItem )

    		    {

    		    delete iItem;

    		    iItem = NULL;

    		    }

    		iItem = CUpnpItem::NewL();

    		// first object is an item, safe to downcast

    		CUpnpItem* item = static_cast<CUpnpItem*>( tempArray[0] );

    		iItem->CopyL( *tempArray[0] );

    		const CUpnpElement& res = UPnPItemUtility::ResourceFromItemL( *item );      		

    		if( iSelectOptimalImageSize )

    		    {

    		    RUPnPElementsArray array;

    		    UPnPItemUtility::GetResElements( *tempArray[0], array );

    		    const CUpnpElement& res = ParseImageResolutions( array );  		    

    		    }

            if(iURI)

                {

                delete iURI;

                iURI = NULL;            

                }                  	        	

            iURI = res.Value().AllocL();

            iObserver->URICheckResult( EUriChecked, item, &res );

    		}

        else

            {

            LOG(_L("[FILL MNGR]\t tempArray.Count() = 0"));

            iObserver->URICheckResult( ENoUriAvailable );

            }        

        }

    else

        {

        LOG(_L("[FILL MNGR]\t err != 0"));

        iObserver->URICheckResult( ENoUriAvailable );

        }

    tempArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &tempArray );            

    }

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

// CCmFmUpnpMngr::SearchResponse

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

//

void CCmFmUpnpMngr::SearchResponse( 

                const TDesC8& /*aSearchResponse*/,

                 TInt /*aError*/,

                 TInt /*aMatches*/,

                 TInt /*aTotalCount*/,

                 const TDesC8& /*aUpdateId*/

                 )

    {

    // None

    }

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

// CCmFmUpnpMngr::SearchResponse

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

//

void CCmFmUpnpMngr::SearchResponse( 

                 TInt /*aStatus*/,

                 TInt /*aTotalCount*/,

                 const RPointerArray<CUpnpObject>& /*aResultArray*/ 

                 )

    {

    // None

    }

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

// CCmFmUpnpMngr::SearchCapabilitiesResponse

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

//

void CCmFmUpnpMngr::SearchCapabilitiesResponse( 

                 TInt /*aStatus*/,

                 const TDesC8& /*aSearchCapabilities*/ 

                 )

    {

    // None

    }                 

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

// CCmFmUpnpMngr::CreateContainerResponse

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

//

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

                                             const TDesC8& /*aObjectId*/ )

    {

    // None

    }

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

// CCmFmUpnpMngr::DeleteObjectResponse

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

//

void CCmFmUpnpMngr::DeleteObjectResponse( TInt /*aStatus*/ )

    {

    // None

    }

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

// CCmFmUpnpMngr::MediaServerDisappeared

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

//

void CCmFmUpnpMngr::MediaServerDisappeared(

    TUPnPDeviceDisconnectedReason /*aReason*/ )

    {

    // None

    }

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

// CCmFmUpnpMngr::ReserveLocalMSServicesCompleted

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

//

void CCmFmUpnpMngr::ReserveLocalMSServicesCompleted( TInt /*aStatus*/ )

    {

    // None

    }

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

// CCmFmUpnpMngr::UPnPDeviceDiscovered

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

//

void CCmFmUpnpMngr::UPnPDeviceDiscovered( const CUpnpAVDevice& /*aDevice*/ )

    {

    }

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

// CCmFmUpnpMngr::UPnPDeviceDisappeared

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

//    

void CCmFmUpnpMngr::UPnPDeviceDisappeared( const CUpnpAVDevice& aDevice )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::UPnPDeviceDisappeared"));

    if( iDevice )

        {

        if( KErrNotFound != iDevice->Uuid().Match( aDevice.Uuid() ) )

            {

            LOG(_L("[FILL MNGR]\t Used server disappeared!"));

            LOG(_L("[FILL MNGR]\t Canceling"));

            iObserver->URICheckResult( ECanceled );

            }        

        }

    }    

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

// CCmFmUpnpMngr::WLANConnectionLost

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

// 

void CCmFmUpnpMngr::WLANConnectionLost()

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::WLANConnectionLost"));

    iObserver->URICheckResult( ECanceled );

    }

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

// CCmFmUpnpMngr::ParseImageResolutions

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

// 

const CUpnpElement& CCmFmUpnpMngr::ParseImageResolutions( 

    RUPnPElementsArray& aResElementsArray )

    {

    LOG(_L("[FILL MNGR]\t CCmFmUpnpMngr::ParseImageResolutions"));

    TInt elementIndex( KErrNone );

    TSize matchingSize( 0, 0 );

    for( TInt i = 0 ; i < aResElementsArray.Count(); i++ )

        {

        const CUpnpAttribute* attribute = 

            UPnPItemUtility::FindAttributeByName( *aResElementsArray[i], 

                KAttributeResolution() ); 

        if( attribute )

            {

            TPtrC8 resolution( attribute->Value() );

            TInt index = resolution.Find( KCmFmXMark );

            if( index != KErrNotFound )

                {

                TLex8 lexH( resolution.Mid( index + 1 ) );

                TInt height( KErrNone );

                TInt err = lexH.Val( height ); 

                TRACE(Print(_L("[FILL MNGR]\t Val( height ) = %d"), err ));

                TInt width( KErrNone );

                TLex8 lexW( resolution.Mid( 0, index ) );

                err = lexW.Val( width );

                TRACE(Print(_L("[FILL MNGR]\t Val( width ) = %d"), err ));

                TRACE(Print(_L("[FILL MNGR]\t Sizes in landscape mode!!!")));

                TRACE(Print(_L("[FILL MNGR]\t Image heigth = %d"), height ));

                TRACE(Print(_L("[FILL MNGR]\t Image width = %d"), width ));

                if( height >= iScreenSize.iWidth && width >= 

                    iScreenSize.iHeight )

                    {

                    if( matchingSize.iHeight == 0 )

                        {

                        matchingSize.iHeight = height;

                        matchingSize.iWidth = width;

                        elementIndex = i;

                        }

                    else

                        {

                        if( matchingSize.iHeight > height && 

                            matchingSize.iWidth > width )

                            {

                            matchingSize.iHeight = height;

                            matchingSize.iWidth = width;

                            elementIndex = i;

                            }

                        }                

                    }                           

                }            

            }

        else

            {

            LOG(_L("[FILL MNGR]\t attribute == NULL"));

            }            

        }

    TRACE(Print(_L("[FILL MNGR]\t Selected height = %d"), 

        matchingSize.iHeight ));

    TRACE(Print(_L("[FILL MNGR]\t Selected width = %d"), 

        matchingSize.iWidth ));

    TRACE(Print(_L("[FILL MNGR]\t Selected elementIndex = %d"), 

        elementIndex ));

    return *aResElementsArray[ elementIndex ];

    }

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

// CCmFmUpnpMngr::ScreenSizeL

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

//