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


#include "upnprootcontenthandler.h"
#include "upnpdevice.h"
#include "upnpcontenthandlerscontroller.h"
#include "upnpdevicetagcontenthandler.h"
#include "upnpdeviceliterals.h"

const TUint8 KReqiuredTagsBoundary(1); //first bit    //specVersion ignored now
enum TFlagsPositions
    {
    EDevicePos = 0,
    //ESpecVersion, required but ignored for now...
    EURLBasePos //optional
    };

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::NewL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CUpnpRootContentHandler* CUpnpRootContentHandler::NewL(
    CUpnpContentHandlersController& aController, CUpnpDevice& aResultDevice,
    TParseType aParseType )
    {
    CUpnpRootContentHandler* rootContentHandler = 
        CUpnpRootContentHandler::NewLC( aController, aResultDevice, aParseType );
    CleanupStack::Pop( rootContentHandler );
    return rootContentHandler;
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::NewLC
// Two-phased constructor. Leaves teh object on the CleanupStack
// -----------------------------------------------------------------------------
//
CUpnpRootContentHandler* CUpnpRootContentHandler::NewLC(
    CUpnpContentHandlersController& aController, CUpnpDevice& aResultDevice,
    TParseType aParseType )
    {
    CUpnpRootContentHandler* rootContentHandler = 
        new (ELeave) CUpnpRootContentHandler( aController, aResultDevice,
                aParseType );
    CleanupStack::PushL( rootContentHandler );
    return rootContentHandler;
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::~CUpnpRootContentHandler
// Destructor of CUpnpRootContentHandler class 
// -----------------------------------------------------------------------------
//
CUpnpRootContentHandler::~CUpnpRootContentHandler()
    {
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::CUpnpRootContentHandler
// Constructor
// -----------------------------------------------------------------------------
//
CUpnpRootContentHandler::CUpnpRootContentHandler(
    CUpnpContentHandlersController& aController, CUpnpDevice& aResultDevice,
    TParseType aParseType ) :
    CUpnpContentHandler( aController ), iResultDevice( aResultDevice ),
            iCurrentState( EInitial ), iParseType( aParseType )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::OnStartElementL
// This method is a callback to indicate an element has been parsed.
// -----------------------------------------------------------------------------
//
void CUpnpRootContentHandler::OnStartElementL( const RTagInfo& aElement,
    const RAttributeArray& /*aAttributes*/)
    {
    if ( EInitial == iCurrentState )
        {
        if ( aElement.LocalName().DesC().Compare( KUpnpDevice )==0 )
            {
            RepeatedTagCheckL( EDevicePos, iFoundTags );
            iController.SetCurrentContentHandlerL( CUpnpDeviceTagContentHandler::NewL(
                iController, iResultDevice, iParseType ) );
            }
        else
            if ( aElement.LocalName().DesC().Compare( KUpnpURLBase )==0 )
                {
                //RepeatedTagCheckL( EURLBasePos, iFoundTags )  NIY
                iCurrentState = EURLBase;
                }
            else
                {
                SetIgnoreHandlerL();
                }
        }
    else
        {
        ASSERT( EURLBase == iCurrentState );
        //User::Leave(KErrArgument)  //content="textonly"
        SetIgnoreHandlerL();
        }
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::OnEndElementL
// This method is a callback to indicate the end of the element has been reached.
// -----------------------------------------------------------------------------
//
void CUpnpRootContentHandler::OnEndElementL( const RTagInfo& aElement )
    {
    switch ( iCurrentState )
        {
        case EInitial:
            ASSERT( aElement.LocalName().DesC().Compare( KUpnpDeviceRoot ) == 0 );
            if ( (iFoundTags.iFlags & KReqiuredTagsBoundary)
                    == KReqiuredTagsBoundary )
                {
                iController.SetPreviousContentHandler();
                }
            else
                {
                User::Leave( KErrArgument ); //required tag not found
                }
            break;
        default:
            iCurrentState = EInitial;
        }
    }

// -----------------------------------------------------------------------------
// CUpnpRootContentHandler::OnContentL
// This method is a callback that sends the content of the element.
// aErrorCode must be KErrNone, and that aBytes should contains complete
// content (one chunk).
// -----------------------------------------------------------------------------
//
void CUpnpRootContentHandler::OnContentL( const TDesC8& aBytes )
    {
    switch ( iCurrentState )
        {
        case EURLBase:
            iResultDevice.SetUrlBaseL( aBytes );
            break;
        default:
            //User::Leave(KErrArgument)  
            break;
        }
    }

//  End of File