/** @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