/*
* Copyright (c) 2010 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 XML parser class.
*
*/

#include "posrevgeocodexmlparser.h"
#include "posrevgeocodelogger.h"


#include <utf.h>
#include <EPos_CPosLandmark.h>

// 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" );


//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::NewL
//------------------------------------------------------------------------------
CPosRevGeoCodeXmlParser* CPosRevGeoCodeXmlParser::NewL( MPosRevGeoCodeXmlObserver& aObserver )
    {
    FUNC("CPosRevGeoCodeXmlParser::NewL");
    CPosRevGeoCodeXmlParser* self = new ( ELeave ) CPosRevGeoCodeXmlParser( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::~CPosRevGeoCodeXmlParser
//------------------------------------------------------------------------------
CPosRevGeoCodeXmlParser::~CPosRevGeoCodeXmlParser()
    {
    FUNC("CPosRevGeoCodeXmlParser::~CPosRevGeoCodeXmlParser");
    delete iParser;
    delete iBuffer;
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::CPosRevGeoCodeXmlParser
//------------------------------------------------------------------------------
CPosRevGeoCodeXmlParser::CPosRevGeoCodeXmlParser( MPosRevGeoCodeXmlObserver& aObserver ):
    iObserver( aObserver ),
    iParser( NULL ),
    iBuffer( NULL ),
    iThoroughfare( EFalse )
    {
    FUNC("CPosRevGeoCodeXmlParser::CPosRevGeoCodeXmlParser");
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::ConstructL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::ConstructL()
    {
    FUNC("CPosRevGeoCodeXmlParser::ConstructL");
    iParser = CParser::NewL( KXmlMimeType,*this );
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::StartParsingL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::StartParsingL( HBufC8 *aXmlInfo,
                                             CPosLandmark* aLandmarkInfo )
    {
    FUNC("CPosRevGeoCodeXmlParser::StartParsingL");
    // Store client's landmark
    iClientLandmark = aLandmarkInfo;
    
    if( iBuffer )
        {
        delete iBuffer;
        iBuffer = NULL;
        }

    iBuffer = HBufC8::NewL( aXmlInfo->Size() );
    TPtr8 ptr = iBuffer->Des();
    ptr.Copy( aXmlInfo->Ptr(),aXmlInfo->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();
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnStartDocumentL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/,
                                                TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnStartDocumentL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnEndDocumentL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnEndDocumentL( TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnEndDocumentL");
    iObserver.OnParseCompletedL( aErrorCode );
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnStartElementL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnStartElementL( const RTagInfo& aElement,
                                               const RAttributeArray& /*aAttributes*/,
                                               TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnStartElementL");
    if ( aErrorCode == KErrNone )
        {
        // 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
            {
            // Nothing to be done here.
            }
        }
    else
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
        
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnEndElementL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnEndElementL");
    if( aErrorCode == KErrNone )
        {
        // at the end of the tag </tag>
        //Set it to ENone
        iCurrentElement = ENone;
        iThoroughfare = EFalse;
        }
    else
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
    
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnContentL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnContentL( const TDesC8 &aBytes, TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnContentL");
    if( aErrorCode == KErrNone )
        {

        if( iCurrentElement == ENone )
            {
            //ignore if the current element is not there
            return;
            }

        // convert the content to UCS-2
        // from UTF-8        
        RBuf buffer;
        CleanupClosePushL(buffer);
        buffer.CreateL( aBytes.Length() );
        CnvUtfConverter::ConvertToUnicodeFromUtf8( buffer,aBytes );
        
        if( iCurrentElement == ECountryName )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldCountry,buffer );
            }
        else if( iCurrentElement == EState )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldState,buffer );
            }
        else if( iCurrentElement == EDistrict )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldDistrict,buffer );
            }
        else if( iCurrentElement == ECity )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldCity,buffer );
            }
        else if( iCurrentElement == EPostalCode )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldPostalCode,buffer );
            }
        else if( iCurrentElement == EThoroughfareName )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldStreet,buffer );
            }
        else if( iCurrentElement == EThoroughfareNumber )
            {
            iClientLandmark->SetPositionFieldL( EPositionFieldStreetExtension,buffer );
            }
        else    
            {
            // Nothing to be done here.
            }
        CleanupStack::PopAndDestroy( &buffer ); 
        }
    else
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
    
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnStartPrefixMappingL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnStartPrefixMappingL( const RString& /*aPrefix*/,
                                                     const RString& /*aUri*/,
                                                     TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnStartPrefixMappingL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
        
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnEndPrefixMappingL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnEndPrefixMappingL( const RString& /*aPrefix*/,
                                                   TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnEndPrefixMappingL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
    
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnIgnorableWhiteSpaceL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/,
                                                      TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnIgnorableWhiteSpaceL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }
    
//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnSkippedEntityL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnSkippedEntityL( const RString& /*aName*/,
                                                TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnSkippedEntityL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnProcessingInstructionL
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnProcessingInstructionL( const TDesC8& /*aTarget*/,
                                                        const TDesC8& /*aData*/, 
                                                        TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnProcessingInstructionL");
    if( aErrorCode != KErrNone )
        {
        iObserver.OnParseCompletedL( aErrorCode );
        }
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::OnError
//------------------------------------------------------------------------------
void CPosRevGeoCodeXmlParser::OnError( TInt aErrorCode )
    {
    FUNC("CPosRevGeoCodeXmlParser::OnError");
    TRAP_IGNORE( iObserver.OnParseCompletedL( aErrorCode ) );
    }

//------------------------------------------------------------------------------
// CPosRevGeoCodeXmlParser::GetExtendedInterface
//------------------------------------------------------------------------------
TAny* CPosRevGeoCodeXmlParser::GetExtendedInterface( const TInt32 /*aUid*/ )
    {
    FUNC("CPosRevGeoCodeXmlParser::GetExtendedInterface");
    return NULL;
    }

// End of File