--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/upnp/upnpstack/serviceframework/src/upnpdevicecontenthandler.cpp Tue Feb 02 01:12:20 2010 +0200
@@ -0,0 +1,331 @@
+/** @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