/** @file

* Copyright (c) 2005-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:  CUpnpAVControlPoint

*

*/

// INCLUDE FILES

#include "upnpavcontrolpoint.h"

#include "upnpargument.h"

#include "upnpstateupdatehandler.h"

#include "upnpactionresponsehandler.h"

#include "upnpavtactionfactory.h"

#include "upnpcdsactionfactory.h"

#include "upnpcmactionfactory.h"

#include "upnprcactionfactory.h"

#define KLogFile _L("UPnPStack.txt")

#include "upnpcustomlog.h"

#include "upnpcons.h"

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

// CUpnpAVControlPoint::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpAVControlPoint* CUpnpAVControlPoint::NewL(

            MUpnpAVControlPointObserver& aAVControlPointObserver)

    {

    CUpnpAVControlPoint* self = 

        new (ELeave) CUpnpAVControlPoint(aAVControlPointObserver);    

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpAVControlPoint::CUpnpAVControlPoint

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C CUpnpAVControlPoint::CUpnpAVControlPoint(

     MUpnpAVControlPointObserver& aAVControlPointObserver)

                : CUpnpControlPoint(),

                  iAVControlPointObserver(aAVControlPointObserver)

    {

    }

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

// CUpnpStateUpdateHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CUpnpAVControlPoint::ConstructL( )

    {

    _LIT8( KMediaServer, "urn:schemas-upnp-org:device:MediaServer" );

    _LIT8( KMediaRenderer, "urn:schemas-upnp-org:device:MediaRenderer" );

    CDesC8ArrayFlat* targetDeviceTypes = new(ELeave) CDesC8ArrayFlat(1);

    CleanupStack::PushL( targetDeviceTypes );

    targetDeviceTypes->AppendL( KMediaServer() );

    targetDeviceTypes->AppendL( KMediaRenderer() );    

    CUpnpControlPoint::ConstructL( *targetDeviceTypes );

    CleanupStack::Pop( targetDeviceTypes );

    targetDeviceTypes->Reset();

    delete targetDeviceTypes; 

    targetDeviceTypes = NULL;

    TPtrC8 devicePtr;

    devicePtr.Set( UpnpSSDP::KUPnPRootDevice );

    SearchL( devicePtr );

    iStateUpdateHandler = CUpnpStateUpdateHandler::NewL( 

        iAVControlPointObserver, 

        *this );

    iActionResponseHandler = CUpnpActionResponseHandler::NewL(

        iAVControlPointObserver,

        *this );

    iAvtActionFactory = CUpnpAvtActionFactory::NewL(

        iAVControlPointObserver,

        *this );

    iCdsActionFactory = CUpnpCdsActionFactory::NewL(

        iAVControlPointObserver,

        *this );

    iCmActionFactory = CUpnpCmActionFactory::NewL(

        iAVControlPointObserver,

        *this );

    iRcActionFactory = CUpnpRcActionFactory::NewL(

        iAVControlPointObserver,

        *this );

    }

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

// CUpnpAVControlPoint::~CUpnpAVControlPoint

// Destructor

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

//

EXPORT_C CUpnpAVControlPoint::~CUpnpAVControlPoint()

    {

    delete iStateUpdateHandler;

    delete iActionResponseHandler;

    delete iAvtActionFactory;

    delete iCdsActionFactory;

    delete iCmActionFactory;

    delete iRcActionFactory;

    }

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

// CUpnpAVControlPoint::InitializeCdsActionFactoryL

// Initialize CdsActionFactory if is NULL

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

//

EXPORT_C void CUpnpAVControlPoint::InitializeCdsActionFactoryL() 

    {

    if (!iCdsActionFactory)

        {

        iCdsActionFactory = CUpnpCdsActionFactory::NewL(

            iAVControlPointObserver,

            *this );

        }    

    }

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

// CUpnpAVControlPoint::StateUpdatedL

// This function implements an inteface and forwards request 

// to stateupdate handler.

// (other items were commented in a header)

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

//

EXPORT_C void CUpnpAVControlPoint::StateUpdatedL(CUpnpService*  aService)

    {

    iStateUpdateHandler->StateUpdated( aService );

    }

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

// CUpnpAVControlPoint::DeviceDiscoveredL

// This function implements an inteface and notifies an observer.

// (other items were commented in a header)

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

//

EXPORT_C void CUpnpAVControlPoint::DeviceDiscoveredL(CUpnpDevice* aDevice)

    {

    iAVControlPointObserver.DeviceDiscoveredL( aDevice );

    }

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

// CUpnpAVControlPoint::DeviceDisappearedL

// This function implements an inteface and notifies an observer.

// (other items were commented in a header)

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

//

EXPORT_C void CUpnpAVControlPoint::DeviceDisappearedL(CUpnpDevice* aDevice)

    {    

    iAVControlPointObserver.DeviceDisappearedL(aDevice);

    }

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

// CUpnpAVControlPoint::ActionResponseReceivedL

// This function ralizes an interface. Functionality is located in separate 

// handler class.

// (other items were commented in a header)

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

//

EXPORT_C void CUpnpAVControlPoint::ActionResponseReceivedL(CUpnpAction* aAction)

    {

    TInt err = iActionResponseHandler->ActionResponseReceived( aAction );

#ifdef _DEBUG

    if (err != KErrNone)

        {

        LOGS("Error in action response received.");

        }

#endif //_DEBUG

    }

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

// CUpnpAVControlPoint::HttpResponseReceivedL

// This function implements an inteface and notifies an observer.

// (other items were commented in a header)

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

//

EXPORT_C void CUpnpAVControlPoint::HttpResponseReceivedL(CUpnpHttpMessage* aMessage)

    {    

    iAVControlPointObserver.HttpResponseL( aMessage );

    }

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

// CUpnpAVControlPoint::Service

// This function returns a pointer to appropriate service instance.

// (other items were commented in a header)

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

//

EXPORT_C CUpnpService* CUpnpAVControlPoint::Service( CUpnpDevice* aMediaServer, 

                                    const TDesC8& aServiceType )

    {

    RPointerArray<CUpnpService>& services = aMediaServer->ServiceList();

    for( TInt i(0); i < services.Count(); i++ )

        {

        if( services[i]->ServiceType().Match( aServiceType ) != KErrNotFound )

            {

            return services[i];

            }

        }

    return NULL;

    }

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

// CUpnpAVControlPoint::AvtSetTransportUriActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtSetTransportUriActionL(const TDesC8& aUuid,

                                                 TInt aInstanceId,

                                                 const TDesC8& aCurrentUri,

                                                 const TDesC8& aCurrentMetaData)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtSetTransportUriActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId,

            aCurrentUri,

            aCurrentMetaData

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtSetNextTransportUriActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtSetNextTransportUriActionL(

                                                 const TDesC8& aUuid,

                                                 TInt aInstanceId,

                                                 const TDesC8& aNextUri,

                                                 const TDesC8& aNextMetaData)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtSetNextTransportUriActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId,

            aNextUri,

            aNextMetaData

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtSeekActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtSeekActionL(const TDesC8& aUuid,

                                      TInt aInstanceId,

                                      const TDesC8& aUnit,

                                      const TDesC8& aTarget)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtSeekActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId,

            aUnit,

            aTarget

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtMediaInfoActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtMediaInfoActionL(const TDesC8& aUuid,

                                           TInt aInstanceId)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtMediaInfoActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtTransportInfoActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtTransportInfoActionL(const TDesC8& aUuid,

                                               TInt aInstanceId)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtTransportInfoActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtPositionInfoActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtPositionInfoActionL(const TDesC8& aUuid,

                                              TInt aInstanceId)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtPositionInfoActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtDeviceCapabilitiesActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtDeviceCapabilitiesActionL(const TDesC8& aUuid,

                                                    TInt aInstanceId)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtDeviceCapabilitiesActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId

            );

        if( err == KErrNone )

            {

            SendL( action );

            CleanupStack::Pop( action );

            return action->SessionId();

            }

        else

            {

            return err;

            }

        }

    }

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

// CUpnpAVControlPoint::AvtTransportSettingsActionL

// This function creates and sends a action.

// (other items were commented in a header)

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

//

EXPORT_C TInt CUpnpAVControlPoint::AvtTransportSettingsActionL(const TDesC8& aUuid,

                                                   TInt aInstanceId)

    {

    const CUpnpDevice* device = Device( aUuid );

    if( !device ) 

        {

        return KErrBadHandle;

        }

    else

        {

        CUpnpAction* action = NULL;

        TInt err( KErrNone );

        err = iAvtActionFactory->AvtTransportSettingsActionLC(

            action,

            (CUpnpDevice*)device,

            aInstanceId

            );

        if( err == KErrNone )

            {

            SendL( action );