/** @file

* 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:  Implements the CUpnpDeviceContentHandler class

 *

*/

#include "upnpdevicecontenthandler.h"

#include "upnpdevice.h"

#include "upnpdeviceimplementation.h"

#include "upnpsilentdeviceimplementation.h"

#include "upnpcontenthandlerscontroller.h"

#include "upnprootcontenthandler.h"

#include "upnpdeviceliterals.h"

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

// CUpnpDeviceContentHandler::NewL

// Two-phased constructor that will parse CUpnpDevice object. If aResultDevice 

// is NULL the result object will be created during the parsing, and will be 

// owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewL(

    CUpnpContentHandlersController& aController, CUpnpDevice* aResultDevice )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        CUpnpDeviceContentHandler::NewLC( aController, aResultDevice );

    CleanupStack::Pop( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::NewLC

// Two-phased constructor that will parse CUpnpDevice object. If aResultDevice 

// is NULL the result object will be created during the parsing, and will be 

// owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object.

// Leaves the object on the CleanupStack

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewLC(

    CUpnpContentHandlersController& aController, CUpnpDevice* aResultDevice )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        new (ELeave) CUpnpDeviceContentHandler( aController, aResultDevice );

    CleanupStack::PushL( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::NewL

// Two-phased constructor that will parse CUpnpDeviceImplementation object. If 

// aResultDeviceImpl is NULL the result object will be created during the parsing, 

// and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object.

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewL(

    CUpnpContentHandlersController& aController,

    CUpnpDeviceImplementation* aResultDeviceImpl )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        CUpnpDeviceContentHandler::NewLC( aController, aResultDeviceImpl );

    CleanupStack::Pop( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::NewLC

// Two-phased constructor that will parse CUpnpDeviceImplementation object. If 

// aResultDeviceImpl is NULL the result object will be created during the parsing, 

// and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object.

// Leaves the object on the CleanupStack

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewLC(

    CUpnpContentHandlersController& aController,

    CUpnpDeviceImplementation* aResultDeviceImpl )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        new (ELeave) CUpnpDeviceContentHandler( aController, aResultDeviceImpl );

    CleanupStack::PushL( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::NewL

// Two-phased constructor that will parse CUpnpSilentDeviceImplementation object. If 

// aResultSilentDeviceImpl is NULL the result object will be created during the parsing, 

// and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object.

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewL(

    CUpnpContentHandlersController& aController,

    CUpnpSilentDeviceImplementation* aResultSilentDeviceImpl )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        CUpnpDeviceContentHandler::NewLC( aController, aResultSilentDeviceImpl );

    CleanupStack::Pop( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::NewLC

// Two-phased constructor that will parse CUpnpSilentDeviceImplementation object. If 

// aResultDeviceImpl is NULL the result object will be created during the parsing, 

// and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object.

// Leaves the object on the CleanupStack

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

//

CUpnpDeviceContentHandler* CUpnpDeviceContentHandler::NewLC(

    CUpnpContentHandlersController& aController,

    CUpnpSilentDeviceImplementation* aResultSilentDeviceImpl )

    {

    CUpnpDeviceContentHandler* deviceContentHandler = 

        new (ELeave) CUpnpDeviceContentHandler( aController, aResultSilentDeviceImpl );

    CleanupStack::PushL( deviceContentHandler );

    return deviceContentHandler;

    }

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

// CUpnpDeviceContentHandler::~CUpnpDeviceContentHandler

// Destructor of CUpnpDeviceContentHandler class 

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

//

CUpnpDeviceContentHandler::~CUpnpDeviceContentHandler()

    {

    if ( iIsDeviceOwned )

        {

        ASSERT( ( EDevice == iParseType && NULL == iResultDeviceImpl && NULL == iResultSilentDeviceImpl ) ||

                ( EDeviceImpl == iParseType && NULL == iResultDevice && NULL == iResultSilentDeviceImpl ) ||  

               ( ESilentDeviceImpl == iParseType && NULL == iResultDevice && NULL == iResultDeviceImpl ) );

        //check if object is in legal state (class invariants)

        delete iResultDevice;

        delete iResultDeviceImpl;

        delete iResultSilentDeviceImpl;

        }

    }

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

// CUpnpDeviceContentHandler::CUpnpDeviceContentHandler

// Constructor that will parse CUpnpDevice object. If aResultDevice is NULL

// the result object will be created during the parsing, and will be owned by

// this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDevice object

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

//

CUpnpDeviceContentHandler::CUpnpDeviceContentHandler(

    CUpnpContentHandlersController& aController, CUpnpDevice* aResultDevice ) :

    CUpnpContentHandler( aController ), iResultDevice( aResultDevice ),

            iIsDeviceOwned( NULL == aResultDevice), iParseType( EDevice )

    {

    }

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

// CUpnpDeviceContentHandler::CUpnpDeviceContentHandler

// Constructor that will parse CUpnpDeviceImplementation object. 

// If aResultDeviceImpl is NULL the result object will be created during the 

// parsing, and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDeviceImpl object

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

//

CUpnpDeviceContentHandler::CUpnpDeviceContentHandler(

    CUpnpContentHandlersController& aController,

    CUpnpDeviceImplementation* aResultDeviceImpl ) :

    CUpnpContentHandler( aController ), iResultDeviceImpl( aResultDeviceImpl ),

            iIsDeviceOwned( NULL == aResultDeviceImpl),

            iParseType( EDeviceImpl )

    {

    }

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

// CUpnpDeviceContentHandler::CUpnpDeviceContentHandler

// Constructor that will parse CUpnpSilentDeviceImplementation object. 

// If aResultSilentDeviceImpl is NULL the result object will be created during the 

// parsing, and will be owned by this CUpnpDeviceContentHandler.

// Otherwise result will be parsed to existing aResultDeviceImpl object

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

//

CUpnpDeviceContentHandler::CUpnpDeviceContentHandler(

    CUpnpContentHandlersController& aController,

    CUpnpSilentDeviceImplementation* aResultSilentDeviceImpl ) :

    CUpnpContentHandler( aController ), iResultSilentDeviceImpl( aResultSilentDeviceImpl ),

            iIsDeviceOwned( NULL == aResultSilentDeviceImpl ),

            iParseType( ESilentDeviceImpl )

    {

    }    

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

// CUpnpDeviceContentHandler::OnStartElementL

// This method is a callback to indicate an element has been parsed.

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

//

void CUpnpDeviceContentHandler::OnStartElementL( const RTagInfo& aElement,

    const RAttributeArray& /*aAttributes*/)

    {

    if ( aElement.LocalName().DesC().Compare( KUpnpDeviceRoot )==0 )

        {

        CUpnpRootContentHandler* rootCH = NULL;

        if ( iIsDeviceOwned )

            {

            switch ( iParseType )

                {

                case EDeviceImpl:

                    delete iResultDeviceImpl;

                    iResultDeviceImpl = NULL;

                    iResultDeviceImpl = new (ELeave) CUpnpDeviceImplementation();

                    break;

                case ESilentDeviceImpl:

                    delete iResultSilentDeviceImpl;

                    iResultSilentDeviceImpl = NULL;

                    iResultSilentDeviceImpl = new (ELeave) CUpnpSilentDeviceImplementation();

                    break;

                case EDevice:

                    delete iResultDevice;

                    iResultDevice = NULL;

                    iResultDevice = new (ELeave) CUpnpDevice();

                    break;

                default:

                    _LIT( KPanicString, "CUpnpDeviceContentHandler::OnStartElementL" );

                    User::Panic( KPanicString, 1 );  

                }

            }

        if ( iParseType == EDeviceImpl )

            {

            rootCH = CUpnpRootContentHandler::NewL( iController,

                *iResultDeviceImpl, EDeviceImpl );

            }

        else if ( iParseType == ESilentDeviceImpl )    

            {

            rootCH = CUpnpRootContentHandler::NewL( iController,

                *iResultSilentDeviceImpl, ESilentDeviceImpl );

            }

        else

            {

            rootCH = CUpnpRootContentHandler::NewL( iController,

                *iResultDevice, EDevice );

            }

        iController.SetCurrentContentHandlerL( rootCH );

        }

    else

        {

        User::Leave( KErrArgument ); //wrong root node

        }

    }

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

// CUpnpDeviceContentHandler::OnEndElementL

// This method is a callback to indicate the end of the element has been reached.

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

//

void CUpnpDeviceContentHandler::OnEndElementL( const RTagInfo& /*aElement*/)

    {

    }

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

// CUpnpServiceContentHandler::OnContentL

// This method is a callback that sends the content of the element.

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

//

void CUpnpDeviceContentHandler::OnContentL( const TDesC8& /*aBytes*/)

    {

    }

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

// CUpnpDeviceContentHandler::GetResultDevice

// Returns parsed CUpnpDevice object, and pass ownership to the caller.

// One shouldn't call this method if CUpnpDeviceContentHandler doesn't have

// ownership CUpnpDevice object.

// @see GetResultDevice( CUpnpDeviceImplementation*& aResultDeviceImpl )

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

//

void CUpnpDeviceContentHandler::GetResultDevice( CUpnpDevice*& aResultDevice )

    {

    ASSERT( iIsDeviceOwned && iParseType==EDevice );

    aResultDevice = iResultDevice;

    iIsDeviceOwned = EFalse;

    iResultDevice = NULL;

    }

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

// CUpnpDeviceContentHandler::GetResultDevice

// Returns parsed CUpnpDeviceImplementation object, and pass ownership to the caller.

// One shouldn't call this method if CUpnpDeviceContentHandler doesn't have

// ownership CUpnpDeviceImplementation object.

// @see GetResultDevice( CUpnpDevice*& aResultDeviceImpl )

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

//

void CUpnpDeviceContentHandler::GetResultDevice(

    CUpnpDeviceImplementation*& aResultDeviceImpl )

    {

    ASSERT( iIsDeviceOwned && iParseType==EDeviceImpl );

    aResultDeviceImpl = iResultDeviceImpl;

    iIsDeviceOwned = EFalse;

    iResultDeviceImpl = NULL;

    }

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

// CUpnpDeviceContentHandler::GetResultDevice

// Returns parsed CUpnpSilentDeviceImplementation object, and pass ownership to the caller.

// One shouldn't call this method if CUpnpDeviceContentHandler doesn't have

// ownership CUpnpSilentDeviceImplementation object.

// @see GetResultDevice( CUpnpDevice*& aResultSilentDeviceImpl )

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

//

void CUpnpDeviceContentHandler::GetResultDevice(

    CUpnpSilentDeviceImplementation*& aResultSilentDeviceImpl )

    {

    ASSERT( iIsDeviceOwned && iParseType==ESilentDeviceImpl );

    aResultSilentDeviceImpl = iResultSilentDeviceImpl;

    iIsDeviceOwned = EFalse;

    iResultSilentDeviceImpl = NULL;

    }

//  End of File