/*

* Copyright (c) 2006-2009 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: Implementation of the Parser 

*/

#include <utf.h>

#include "internaladdressinfo.h"

#include "xmlhandler.h"

#include "locationmanagerdebug.h"

using namespace xmlhandler;

// CONSTANTS

_LIT8( KXmlMimeType, "text/xml" );

_LIT8( KCountry, "country" );

_LIT8( KState, "state" );

_LIT8( KDistrict, "district" );

_LIT8( KCity, "city" );

_LIT8( KPostalCode, "postCode" );

_LIT8( KThoroughfare, "thoroughfare" );

_LIT8( KNameTag, "name" );

_LIT8( KNumberTag, "number" );

// METHODS DEFINITION

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

// CXmlHandler::NewL

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

CXmlHandler* CXmlHandler::NewL( MXmlHandlerObserver& aObserver,  CInternalAddressInfo *aAddressInfo )

    {

    LOG("CXmlHandler::NewL ,begin");

    CXmlHandler* self = CXmlHandler::NewLC( aObserver, aAddressInfo );

    CleanupStack::Pop(); //self

    return self;

    }

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

// CXmlHandler::NewLC

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

CXmlHandler* CXmlHandler::NewLC( MXmlHandlerObserver& aObserver,  CInternalAddressInfo *aAddressInfo  )

    {

    LOG("CXmlHandler::NewLC ,begin");

    CXmlHandler* self = new ( ELeave ) CXmlHandler( aObserver, aAddressInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CXmlHandler::~CXmlHandler

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

CXmlHandler::~CXmlHandler()

    {

    LOG("CXmlHandler::~CXmlHandler");

    delete iParser;

    iParser = NULL;

    delete iBuffer;

    iBuffer = NULL;

    }

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

// CXmlHandler::CXmlHandler

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

CXmlHandler::CXmlHandler( MXmlHandlerObserver& aObserver, CInternalAddressInfo *aAddressInfo  ):

    iObserver( aObserver ),

    iParser( NULL ),

    iBuffer( NULL ),

    iAddressInfo( aAddressInfo ),

    iThoroughfare( EFalse )

    {

    }

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

// CXmlHandler::ConstructL

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

void CXmlHandler::ConstructL()

    {

    LOG("CXmlHandler::ConstructL ,begin");

    iParser = CParser::NewL( KXmlMimeType, *this );

    }

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

// CXmlHandler::StartParsingL()

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

void CXmlHandler::StartParsingL( HBufC8 *aBuf )

    {

	LOG("CXmlHandler::StartParsingL ,begin");

     //Reset the address values before starting new content parsing

     iAddressInfo->ResetAddressInfoL();

    if( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    iBuffer = HBufC8::NewL( aBuf->Size() );

    TPtr8 ptr = iBuffer->Des();

    ptr.Copy( aBuf->Ptr() ,  aBuf->Size() );

    // Now, we have the whole file content in iBuffer.

    // We are ready to parse the XML content.

    iParser->ParseBeginL();

    iParser->ParseL( *iBuffer );

    // Since we read the whole file contents within one-shot,

    // we can call ParseEndL() right after calling ParseL().

    iParser->ParseEndL();

	LOG("CXmlHandler::StartParsingL ,end");

    }

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

// CXmlHandler::OnStartDocumentL()

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

void CXmlHandler::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/,

                                    TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnStartDocumentL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

	LOG("CXmlHandler::OnStartDocumentL ,end");

    }

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

// CXmlHandler::OnEndDocumentL()

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

void CXmlHandler::OnEndDocumentL( TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnEndDocumentL ,Errcode - %d", aErrorCode);

    iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

    }

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

// CXmlHandler::OnStartElementL()

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

void CXmlHandler::OnStartElementL( const RTagInfo& aElement,

                                   const RAttributeArray& /*aAttributes*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnStartElementL , Errorcode - %d", aErrorCode);

    if ( KErrNone == aErrorCode )

        {

        // If we find the start of an element, we write to the screen,

        // for example: "<tag>"

        if( !aElement.LocalName().DesC().Compare( KCountry ) )

            {

            iCurrentElement = ECountryName;

            }

        else if( !aElement.LocalName().DesC().Compare( KState ) )

            {

            iCurrentElement = EState;

            }

        else if( !aElement.LocalName().DesC().Compare( KCity ) )

            {

            iCurrentElement = ECity;

            }

        else if( !aElement.LocalName().DesC().Compare( KDistrict ) )

            {

            iCurrentElement = EDistrict;

            }

        else if( !aElement.LocalName().DesC().Compare( KPostalCode )  )

            {

            iCurrentElement = EPostalCode;

            }

        else if( !aElement.LocalName().DesC().Compare( KThoroughfare )  )

            {

            iThoroughfare = ETrue;

            }

        else if( !aElement.LocalName().DesC().Compare( KNameTag ) && iThoroughfare )

            {

            iCurrentElement = EThoroughfareName;

            }

        else if( !aElement.LocalName().DesC().Compare( KNumberTag ) && iThoroughfare )

            {

            iCurrentElement = EThoroughfareNumber;

            }

        else

            {

            ///Do something

            }

        }

    else

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

	LOG("CXmlHandler::OnStartElementL ,end");

    }

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

// CXmlHandler::OnEndElementL()

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

void CXmlHandler::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnEndElementL ,Error code - %d", aErrorCode);

    if( KErrNone == aErrorCode )

        {

        // at the end of the tag </tag>

        //Set it to ENone

        iCurrentElement = ENone;

        iThoroughfare = EFalse;

        }

    else

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    }

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

// CXmlHandler::OnContentL()

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

void CXmlHandler::OnContentL( const TDesC8 &aBytes, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnContentL ,Errorcode - %d", aErrorCode);

    if( KErrNone == aErrorCode )

        {

        if( iCurrentElement == ENone )

            {

            //ignore if the current element is not there

            return;

            }

        // convert the content to UCS-2

        // from UTF-8        

        RBuf buffer;

        buffer.CreateL( aBytes.Length() );

        CleanupClosePushL(buffer);

        CnvUtfConverter::ConvertToUnicodeFromUtf8( buffer , aBytes );

        if( iCurrentElement == ECountryName )

            {

            iAddressInfo->SetCountryName( buffer );

            }

        else if( iCurrentElement == EState )

            {

            iAddressInfo->SetState( buffer );

            }

        else if( iCurrentElement == EDistrict )

            {

            iAddressInfo->SetDistrict( buffer );

            }

        else if( iCurrentElement == ECity )

            {

            iAddressInfo->SetCity( buffer );

            }

        else if( iCurrentElement == EPostalCode )

            {

            iAddressInfo->SetPincode( buffer );

            }

        else if( iCurrentElement == EThoroughfareName )

            {

            iAddressInfo->SetThoroughfareName( buffer );

            }

        else if( iCurrentElement == EThoroughfareNumber )

            {

            iAddressInfo->SetThoroughfareNumber( buffer );

            }

        else

            {

                 ///Do something

            }

        CleanupStack::PopAndDestroy(); // buffer

        }

    else

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

	LOG("CXmlHandler::OnContentL ,end");

    }

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

// CXmlHandler::OnStartPrefixMappingL()

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

void CXmlHandler::OnStartPrefixMappingL( const RString& /*aPrefix*/,

                                         const RString& /*aUri*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnStartPrefixMappingL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

    }

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

// CXmlHandler::OnEndPrefixMappingL()

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

void CXmlHandler::OnEndPrefixMappingL( const RString& /*aPrefix*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnEndPrefixMappingL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

    }

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

// CXmlHandler::OnIgnorableWhiteSpaceL()

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

void CXmlHandler::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/,TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnIgnorableWhiteSpaceL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

    }

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

// CXmlHandler::OnSkippedEntityL()

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

void CXmlHandler::OnSkippedEntityL( const RString& /*aName*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnSkippedEntityL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

    }

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

// CXmlHandler::OnProcessingInstructionL()

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

void CXmlHandler::OnProcessingInstructionL( const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnProcessingInstructionL ,Error code - %d", aErrorCode);

    if( KErrNone != aErrorCode )

        {

        iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo );

        }

    else

        {

        // Do nothing

        }

    }

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

// CXmlHandler::OnError()

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

void CXmlHandler::OnError( TInt aErrorCode )

    {

    LOG1("CXmlHandler::OnError ,Error code - %d", aErrorCode);

    TRAP_IGNORE( iObserver.OnParseCompletedL( aErrorCode, *iAddressInfo ) );

    }

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

// CXmlHandler::GetExtendedInterface()

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

TAny* CXmlHandler::GetExtendedInterface( const TInt32 /*aUid*/ )

    {

    return 0;

    }

// End of File