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


#include "upnpiconcontenthandler.h"
#include "upnpcontenthandlerscontroller.h"
#include "upnpicon.h"
#include "upnpdeviceliterals.h"

//const TUint8 KReqiuredTagsBoundary(31) //first five bits
enum TFlagsPositions
    {
    EMimetypePos = 0,
    EWidthPos,
    EHeightPos,
    EDepthPos,
    EUrlPos //all required
    };

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::NewL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CUpnpIconContentHandler* CUpnpIconContentHandler::NewL(
    CUpnpContentHandlersController& aController, CUpnpIcon& aResultIcon )
    {
    CUpnpIconContentHandler* iconContentHandler = 
        CUpnpIconContentHandler::NewLC( aController, aResultIcon );
    CleanupStack::Pop( iconContentHandler );
    return iconContentHandler;
    }

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::NewLC
// Two-phased constructor. Leaves teh object on the CleanupStack
// -----------------------------------------------------------------------------
//
CUpnpIconContentHandler* CUpnpIconContentHandler::NewLC(
    CUpnpContentHandlersController& aController, CUpnpIcon& aResultIcon )
    {
    CUpnpIconContentHandler* iconContentHandler = 
        new (ELeave) CUpnpIconContentHandler( aController, aResultIcon );
    CleanupStack::PushL( iconContentHandler );
    return iconContentHandler;
    }

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

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::CUpnpIconContentHandler
// Constructor
// -----------------------------------------------------------------------------
//
CUpnpIconContentHandler::CUpnpIconContentHandler(
    CUpnpContentHandlersController& aController, CUpnpIcon& aResultIcon ) :
    CUpnpContentHandler( aController ), iResultIcon( aResultIcon ),
            iCurrentState( EInitial )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::OnStartElementL
// This method is a callback to indicate an element has been parsed.
// -----------------------------------------------------------------------------
//
void CUpnpIconContentHandler::OnStartElementL( const RTagInfo& aElement,
    const RAttributeArray& /*aAttributes*/)
    {
    if ( EInitial == iCurrentState  )
        {
        const TDesC8& elementName(aElement.LocalName().DesC() );
        if ( elementName.Compare( KUpnpMimetype ) == 0 )
            {
            //            RepeatedTagCheckL( EMimetypePos, iFoundTags ) NIY
            iCurrentState = EMimeType;
            }
        else if ( elementName.Compare( KUpnpWidth ) == 0 )
            {
            //            RepeatedTagCheckL( EWidthPos, iFoundTags )    NIY
            iCurrentState = EWidth;
            }
        else if ( elementName.Compare( KUpnpHeight ) == 0 )
            {
            //            RepeatedTagCheckL( EHeightPos, iFoundTags )   NIY
            iCurrentState = EHeight;
            }
        else if ( elementName.Compare( KUpnpDepth ) == 0 )
            {
            //            RepeatedTagCheckL( EDepthPos, iFoundTags )    NIY
            iCurrentState = EDepth;
            }
        else if ( elementName.Compare( KUpnpUrl ) == 0 )
            {
            //            RepeatedTagCheckL( EUrlPos, iFoundTags )      NIY
            iCurrentState = EUrl;
            }
        else
            {
            SetIgnoreHandlerL();
            }
        }
    else
        {
        //User::Leave( KErrArgument )    
        SetIgnoreHandlerL();
        }
    }

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

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::OnContentL
// This method is a callback that sends the content of the element.
// -----------------------------------------------------------------------------
//
void CUpnpIconContentHandler::OnContentL( const TDesC8& aBytes )
    {
    switch ( iCurrentState )
        {
        case EMimeType:
            iResultIcon.SetMimeTypeL( aBytes );
            break;
        case EWidth:
            iResultIcon.SetWidthL( ParseIntL( aBytes ) );
            break;
        case EHeight:
            iResultIcon.SetHeightL( ParseIntL( aBytes ) );
            break;
        case EDepth:
            iResultIcon.SetDepthL( ParseIntL( aBytes ) );
            break;
        case EUrl:
            iResultIcon.SetUrlL( aBytes );
            break;
        default:
            ASSERT( EInitial == iCurrentState );
            //User::Leave(KErrArgument) 
            break;
        }
    }

// -----------------------------------------------------------------------------
// CUpnpIconContentHandler::ParseIntL
// Parses and returns int value stored in descriptor, or leaves with KErrArgument
// if parsing failes.
// -----------------------------------------------------------------------------
//
TInt CUpnpIconContentHandler::ParseIntL( const TDesC8& aToParse )
    {
    TLex8 val(aToParse);
    TInt ret(0);
    TInt err = val.Val( ret );
    //    if ( err )
    //        {
    //        User::Leave( KErrArgument ) no error checking for now
    //        }
    return ret;
    }

//  End of File