/*

* Copyright (c) 2005-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:  Parser for Voice Commands XML files

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <featmgr.h>

#include <parser.h>

#include <utf.h>

#include "vcxmlparser.h"

#include "vcresource.h"

#include "rubydebug.h"

// CONSTANTS

// XML Tags

_LIT8( KXmlDocumentTag, "nssvcommands" );

_LIT8( KXmlFolderTag, "vcommandfolder" );

_LIT8( KXmlVCommandTag, "vcommand" );

_LIT8( KXmlSpokenTag, "spoken" ); 

_LIT8( KXmlWrittenTag, "written" ); 

_LIT8( KXmlExecutesTag, "executes" );

_LIT8( KXmlCmdlineparamsTag, "cmdlineparams" );

_LIT8( KXmlIconTag, "icon" );

_LIT8( KXmlTooltipTag, "tooltip" );

// XML attributes

_LIT8( KXmlVersionAttr, "version" );

_LIT8( KXmlLocFileAttr, "localizationfile" );

_LIT8( KXmlLocAttr, "locindex" );

_LIT8( KXmlFolderTitleLocAttr, "titlelocindex" );

_LIT8( KXmlFolderIconFileAttr, "iconfile" );

_LIT8( KXmlFolderIconIndexAttr, "iconindex" );

_LIT8( KXmlTtsAttr, "tts" );

_LIT8( KXmlModifiableAttr, "modifiable" );

_LIT8( KXmlUidAttr, "uid" );

_LIT8( KXmlExeAttr, "exe" );

// XML attribute values

_LIT8( KXmlVersionValue, "1.0" );

_LIT8( KXmlTrueValue, "true" );

_LIT8( KXmlFalseValue, "false" );

// XML file MIME type

_LIT8( KMimeType, "text/xml" );

static const TInt KNoTags = 0;

static const TInt KLastTag = 1;

// ============================ MEMBER FUNCTIONS ===============================

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

// CVcXmlParser::CVcXmlParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVcXmlParser::CVcXmlParser( RFs& aRFs, MVcXmlParserObserver& aObserver )

 : iObserver( aObserver ), iRFs( aRFs )

    {

    // Nothing

    }

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

// CVcXmlParser::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVcXmlParser::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CVcXmlParser::ConstructL" );

    ResetVCommandFolder();

    using namespace Xml;

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

    }

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

// CVcXmlParser::NewL

// Two-phased constructor.

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

//

CVcXmlParser* CVcXmlParser::NewL( RFs& aRFs, MVcXmlParserObserver& aObserver )

    {

    CVcXmlParser* self = new( ELeave ) CVcXmlParser( aRFs, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcXmlParser::~CVcXmlParser

// Destructor.

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

//

CVcXmlParser::~CVcXmlParser()

    {

    iXmlNesting.Close();

    ResetVCommandInfo();

    delete iResource;

    delete iFolder;

    delete iFolderTitle;

    delete iFolderIconFile;

    delete iAttributeValue;

    delete iParser;

    delete iParameters;

    delete iParameters8;

    delete iAppName;

    }

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

// CVcXmlParser::ParseFileL

// Parses a specific file.

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

//

void CVcXmlParser::ParseFileL( const TFileName& aFileName )

    {

    RUBY_DEBUG_BLOCK( "CVcXmlParser::ParseFileL" );

    iParser->ParseBeginL();

    ParseL( *iParser, iRFs, aFileName );

    }

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

// CVcXmlParser::OnStartDocumentL

// Callback from XML parser when beginning of document has been found

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

//

void CVcXmlParser::OnStartDocumentL( const Xml::RDocumentParameters& /*aDocParam*/, 

                                     TInt aErrorCode )

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::OnStartDocumentL" );

    delete iResource;

    iResource = NULL;

    if ( ( iXmlNesting.Count() == KNoTags ) && ( aErrorCode == KErrNone ) )

        {

        iXmlNesting.Append( EXmlStarted );

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    }

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

// CVcXmlParser::OnEndDocumentL

// Callback from XML parser when end of document has been reached

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

//

void CVcXmlParser::OnEndDocumentL( TInt aErrorCode )

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::OnEndDocumentL" );

    if ( ( iXmlNesting.Count() == KLastTag ) && ( aErrorCode == KErrNone ) )

        {

        iXmlNesting.Reset();

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    }

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

// CVcXmlParser::OnStartElementL

// Callback from XML parser when new element has been found

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

//

void CVcXmlParser::OnStartElementL( const Xml::RTagInfo& aElement, 

	                                const Xml::RAttributeArray& aAttributes, 

	                                TInt aErrorCode )

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::OnStartElementL" );

    __ASSERT_ALWAYS( iXmlNesting.Count() > 0, User::Leave( KErrCorrupt ) );    

    User::LeaveIfError( aErrorCode );

    HBufC8* name = ToLowercaseLC( aElement.LocalName().DesC() );

    // Check what was the previous tag

    switch ( iXmlNesting[ iXmlNesting.Count() - 1 ] )

        {

        case EXmlStarted:

            {

            if ( !ResolveDocumentTagL( name->Des(), aAttributes ) )

                {

                User::Leave( KErrNotFound );

                }

            break;

            }

        case EXmlDocument:

            {

            if ( !ResolveFolderTagL( name->Des(), aAttributes ) )

                {

                if ( !ResolveVCommandTagL( name->Des(), aAttributes ) )

                    {

                    RUBY_DEBUG0( "VC XML ERROR: <vcommandfolder> or <vcommand> exptected but not found" );

                    User::Leave( KErrNotFound );

                    }

                }

            break;

            }

        case EXmlFolder:

            {

            if ( !ResolveVCommandTagL( name->Des(), aAttributes ) )

                {

                RUBY_DEBUG0( "VC XML ERROR: <vcommand> exptected but not found" );

                User::Leave( KErrNotFound );

                }

            // New voice command starts

            ResetVCommandInfo();

            break;

            }

        case EXmlVCommand:

            {

            if ( !ResolveSpokenTagL( name->Des(), aAttributes ) )

                {

                if ( !ResolveWrittenTagL( name->Des(), aAttributes ) )

                    {

                    if ( !ResolveExecutesTagL( name->Des(), aAttributes ) )

                        {

                        if ( !ResolveCmdlineparamsTag( name->Des(), aAttributes ) )

                            {

                            if ( !ResolveIconTagL( name->Des(), aAttributes ) )

                                {

                                if ( !ResolveTooltipTagL( name->Des(), aAttributes ) )

                                    {

                                    RUBY_DEBUG0( "VC XML ERROR: <spoken> <written> <executes> or <cmdlineparams> exptected but not found" );   

                                    User::Leave( KErrNotFound );

                                    }

                                }

                            }

                        }

                    }

                }

            break;

            }

        default:

            {

            RUBY_DEBUG0( "VC XML ERROR: Unexpected starting tag found" );

            User::Leave( KErrNotFound );

            break;

            }

        }

    CleanupStack::PopAndDestroy( name );

    }

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

// CVcXmlParser::OnEndElementL

// Callback from XML parser when ending tag has been found

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

//

void CVcXmlParser::OnEndElementL( const Xml::RTagInfo& aElement, 

                                  TInt aErrorCode )

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::OnEndElementL" );

    __ASSERT_ALWAYS( iXmlNesting.Count() > 0, User::Leave( KErrCorrupt ) );

    User::LeaveIfError( aErrorCode );

    HBufC8* name = ToLowercaseLC( aElement.LocalName().DesC() );

    switch ( iXmlNesting[ iXmlNesting.Count() - 1 ] )

        {

        case EXmlDocument:

            {

            PopFromStackIfFoundL( name->Des(), KXmlDocumentTag );

            break;

            }

        case EXmlFolder:

            {

            PopFromStackIfFoundL( name->Des(), KXmlFolderTag );

            ResetVCommandFolder();

            break;

            }

        case EXmlVCommand:

            {

            PopFromStackIfFoundL( name->Des(), KXmlVCommandTag );

            CheckVoiceCommmandData();

            break;

            }

         case EXmlSpoken:

            {

            PopFromStackIfFoundL( name->Des(), KXmlSpokenTag );

            break;

            }

         case EXmlWritten:

            {

            PopFromStackIfFoundL( name->Des(), KXmlWrittenTag );

            break;

            }

         case EXmlExecutes:

            {

            PopFromStackIfFoundL( name->Des(), KXmlExecutesTag );

            break;

            }

         case EXmlCmdlineparams:

            {

            PopFromStackIfFoundL( name->Des(), KXmlCmdlineparamsTag );   

            // Convert content of <cmdlineparams> into unicode

            // First trim out unnecessary white space

            TPtr8 des8( iParameters8->Des() );

            des8.Trim();

            // Delete previous unicode buffer and create new

            delete iParameters;

            iParameters = NULL;

            iParameters = CnvUtfConverter::ConvertToUnicodeFromUtf8L( des8 );

            break;

            }

         case EXmlIcon:

            {

            PopFromStackIfFoundL( name->Des(), KXmlIconTag );

            break;

            }

         case EXmlTooltip:

            {

            PopFromStackIfFoundL( name->Des(), KXmlTooltipTag );

            break;

            }

        default:

            {

            RUBY_DEBUG0( "VC XML ERROR: Ending tag found when not expected" );

            User::Leave( KErrGeneral );

            break;

            }

        }

    CleanupStack::PopAndDestroy( name );

    }

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

// CVcXmlParser::PopFromStackIfFoundL

// Checks that last item on stack is the expected one

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

//

void CVcXmlParser::PopFromStackIfFoundL( const TDesC8& aTagName, const TDesC8& aExpectedTag )

    {

    if ( aTagName != aExpectedTag )

        {

        RUBY_DEBUG0( "VC XML ERROR: Unexpected ending tag found" );

        User::Leave( KErrNotFound );

        }

    iXmlNesting.Remove( iXmlNesting.Count() - 1 );    

    }

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

// CVcXmlParser::OnContentL

// Callback from XML parser when element has some content

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

//

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

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::OnContentL" );

    User::LeaveIfError( aErrorCode );

    TInt lastTag = iXmlNesting.Count() - 1;

    if ( iXmlNesting[ lastTag ] == EXmlCmdlineparams )

        {

        if ( !iParameters8 )

            {

            // Create new buffer

            iParameters8 = HBufC8::NewL( aBytes.Size() );

            TPtr8 des( iParameters8->Des() );

            des.Copy( aBytes );

            }

        else

            {

            // Append at the end of previous stuff

            iParameters8 = iParameters8->ReAllocL( iParameters8->Size() + aBytes.Size() );

            TPtr8 des( iParameters8->Des() );

            des.Append( aBytes );

            }

        RUBY_DEBUG0( "<cmdlineparams> content resolved" );

        }

    }

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

// CVcXmlParser::OnStartPrefixMappingL

// Callback from XML parser

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

//

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

	                                      const RString& /*aUri*/, 

	                                      TInt /*aErrorCode*/ )

    {

    // Nothing

    }

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

// CVcXmlParser::OnEndPrefixMappingL

// Callback from XML parser

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

//

void CVcXmlParser::OnEndPrefixMappingL( const RString& /*aPrefix*/, 

                                        TInt /*aErrorCode*/ )

    {

    // Nothing

    }

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

// CVcXmlParser::OnIgnorableWhiteSpaceL

// Callback from XML parser

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

//

void CVcXmlParser::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/, 

                                           TInt /*aErrorCode*/ )

    {

    // Nothing

    }

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

// CVcXmlParser::OnSkippedEntityL

// Callback from XML parser

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

//

void CVcXmlParser::OnSkippedEntityL( const RString& /*aName*/, 

                                     TInt /*aErrorCode*/ )

    {

    // Nothing

    }

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

// CVcXmlParser::OnProcessingInstructionL

// Callback from XML parser

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

//

void CVcXmlParser::OnProcessingInstructionL( const TDesC8& /*aTarget*/, 

                                             const TDesC8& /*aData*/, 

	                                         TInt /*aErrorCode*/ )

    {

    // Nothing

    }

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

// CVcXmlParser::OnError

// Callback from XML parser when general error has occured

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

//

#if defined(_DEBUG) && !defined(__RUBY_DEBUG_DISABLED)

void CVcXmlParser::OnError( TInt aErrorCode )

    {

    RUBY_DEBUG1( "CVcXmlParser::OnError general error: [%d]", aErrorCode );

    }

#else

void CVcXmlParser::OnError( TInt /*aErrorCode*/ )

    {

    // Nothing

    }

#endif // #if defined(_DEBUG) && !defined(__RUBY_DEBUG_DISABLED)

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

// CVcXmlParser::GetExtendedInterface

// Callback from XML parser

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

//

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

    {

    return NULL;

    }

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

// CVcXmlParser::CheckAttributeL

// Checks the value of certain attribute

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

//

TBool CVcXmlParser::CheckAttributeL( const Xml::RAttributeArray& aAttributes,

                                     const TDesC8& aAttribute, const TDesC8& aValue )

    {

    RUBY_DEBUG_BLOCKL( "CVcXmlParser::CheckAttributeL" );

    TBool resolved( EFalse );

    // Loop through attribute list

    for ( TInt iCounter = 0 ; iCounter < aAttributes.Count() ; iCounter++ )

        {        

        HBufC8* name = ToLowercaseLC( aAttributes[iCounter].Attribute().LocalName().DesC() );

        if ( name->Des() == aAttribute )

            {

            HBufC8* value = ToLowercaseLC( aAttributes[iCounter].Value().DesC() );

            // If value is null descriptor, then we just check if attribute exists