/*

* Copyright (c) 2007-2008 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 CAcpXmlHandler methods

*

*/

#include <escapeutils.h>

#include "acpprovider.h"

#include "acpxmlhandler.h"

#include "accountcreationpluginlogger.h"

#include "macpxmlhandlerobserver.h"

#include "accountcreationengineconstants.h"

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

// CAcpXmlHandler::CAcpXmlHandler

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

//

CAcpXmlHandler::CAcpXmlHandler( MAcpXmlHandlerObserver& aObserver )

    : CActive( EPriorityStandard ),

    iObserver( aObserver )

    {

    // Add active scheduler.

    CActiveScheduler::Add( this );

    }

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

// CAcpXmlHandler::ConstructL

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

//

void CAcpXmlHandler::ConstructL()

    {

    ACPLOG( "CAcpXmlHandler::ConstructL begin" );

    // Create XML parser

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

    ACPLOG( "CAcpXmlHandler::ConstructL end" );

    }

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

// CAcpXmlHandler::NewL

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

//

CAcpXmlHandler* CAcpXmlHandler::NewL( MAcpXmlHandlerObserver& aObserver )

    {

    CAcpXmlHandler* self = CAcpXmlHandler::NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAcpXmlHandler::NewLC

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

//

CAcpXmlHandler* CAcpXmlHandler::NewLC( MAcpXmlHandlerObserver& aObserver )

    {

    CAcpXmlHandler* self = new ( ELeave ) CAcpXmlHandler( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CAcpXmlHandler::~CAcpXmlHandler

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

//

CAcpXmlHandler::~CAcpXmlHandler()

    {

    ACPLOG( "CAcpXmlHandler::~CAcpXmlHandler begin" );

    Cancel(); // Ensures that the parsing is stopped

    delete iParser;

    delete iBuffer;

    delete iOngoingAttr;

    delete iProvider;

    ACPLOG( "CAcpXmlHandler::~CAcpXmlHandler end" );

    }

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

// CAcpXmlHandler::StartParsingL

// Starts parsing xml with given filename.

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

//

void CAcpXmlHandler::StartParsingL( const TFileName& aFilename )

    {

    ACPLOG( "CAcpXmlHandler::StartParsingL begin" );

    // Save the filename because of deleting file later on.

    iFilename.Append( aFilename );

    // Leave if parsing is active.

    if ( IsActive() )

        {

        User::Leave( KErrInUse );

        }

    // Connect to fileserver and open xml file to be parsed.    

    User::LeaveIfError( iFileServer.Connect() );

    User::LeaveIfError( iFile.Open( iFileServer, aFilename, EFileRead ) );

    delete iBuffer;

    iBuffer = NULL;    

    TEntry entry;

    // Get size of file.

    User::LeaveIfError( iFileServer.Entry( aFilename, entry ) );

    TInt fileSize = entry.iSize;

    // Create buffer for file reading and start process.

    iBuffer = HBufC8::NewL( fileSize );

    TPtr8 ptr( iBuffer->Des() );

    ptr.Zero();

    iFile.Read( ptr, fileSize, iStatus );

    SetActive();

    iParser->ParseBeginL();

    ACPLOG( "CAcpXmlHandler::StartParsingL end" );

    }

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

// CAcpXmlHandler::HandleFinishedProviderL

// Handles finished provider and notifies observer.

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

//

void CAcpXmlHandler::HandleFinishedProviderL()

    {

    ACPLOG( "CAcpXmlHandler::HandleFinishedProviderL" );

    // Provider exists, save it by calling observer.

    if ( iProvider )

        {

        iObserver.NotifyParsedProviderL( *iProvider );    

        delete iProvider;

        iProvider = NULL;

        }

    // Start new provider by creating instance from CAcpProvider.

    iProvider = CAcpProvider::NewL();

    }

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

// CAcpXmlHandler::DoCancel

// From CActive.

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

//

void CAcpXmlHandler::DoCancel()

    {

    ACPLOG( "CAcpXmlHandler::DoCancel begin" );

    ACPLOG( "CAcpXmlHandler::DoCancel - ReadCancel" );

    iFile.ReadCancel();

    TRAP_IGNORE( iParser->ParseEndL() );

    iFileServer.Delete( iFilename ); // Delete old file

    iFile.Close();

    iFileServer.Close();

    delete iBuffer;

    iBuffer = NULL;

    delete iOngoingAttr;

    iOngoingAttr = NULL;

    ACPLOG( "CAcpXmlHandler::DoCancel end" );

    }

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

// CAcpXmlHandler::RunL

// From CActive.

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

//

void CAcpXmlHandler::RunL()

    {

    ACPLOG( "CAcpXmlHandler::RunL begin" );

    if ( KErrNone == iStatus.Int() )

        {

        // When buffer length is zero, we have reached end of the document.

        if ( !iBuffer->Length() )

            {

            ACPLOG( " - end of XML document reached" );

            DoCancel();

            }

        // Otherwise continue reading of Xml file.

        else

            {

            iParser->ParseL( *iBuffer );

            TPtr8 ptr( iBuffer->Des() );

            iFile.Read( ptr, iStatus );

            SetActive();

            ACPLOG( " - continuing reading XML document" );

            }

        }

    else

        {

        iObserver.NotifyParsingCompleted( iStatus.Int() );

        }

    ACPLOG( "CAcpXmlHandler::RunL end" );

    }

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

// CAcpXmlHandler::OnStartDocumentL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnStartDocumentL( 

    const RDocumentParameters& /*aDocParam*/,

    TInt aErrorCode )

    {

    if ( KErrNone != aErrorCode )

        {

        ACPLOG2( "CAcpXmlHandler::OnStartDocumentL: error=%d", aErrorCode );

        iObserver.NotifyParsingCompleted( aErrorCode );

        }

    }

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

// CAcpXmlHandler::OnEndDocumentL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnEndDocumentL( TInt aErrorCode )

    {

    ACPLOG2( "CAcpXmlHandler::OnEndDocumentL begin: error=%d", aErrorCode );

    if ( KErrNone == aErrorCode )

        {

        // Save last one.

        HandleFinishedProviderL();

        delete iProvider;

        iProvider = NULL;

        }

    iObserver.NotifyParsingCompleted( aErrorCode );

    ACPLOG( "CAcpXmlHandler::OnEndDocumentL end" );

    }

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

// CAcpXmlHandler::OnStartElementL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnStartElementL( 

    const RTagInfo& aElement,

    const RAttributeArray& , 

    TInt aErrorCode )

    {

    TBuf<KMaxElementLength>element;

    element.Copy(aElement.LocalName().DesC());

    ACPLOG2( "CAcpXmlHandler::OnStartElementL: element=%S", &element );

    ACPLOG2( "CAcpXmlHandler::OnStartElementL: error=%d", aErrorCode );

    if ( KErrNone == aErrorCode )

        {

        // No need to go through attributes since they're not used.

        // Parsing has reached to some of supported elements.

        // Save element value to member data for further actions.

        TPtrC8 ptr = aElement.LocalName().DesC();

        if ( !ptr.Compare( KServiceProvider ) ||

            !ptr.Compare( KProviderName ) ||

            !ptr.Compare( KIconUrl ) ||

            !ptr.Compare( KSisUrl ) ||

            !ptr.Compare( KCreateUrl ) ||

            !ptr.Compare( KActivateUrl ) ||

            !ptr.Compare( KProviderDescription ) ||

            !ptr.Compare( KProviderType ) ||

            !ptr.Compare( KReportUrl ) )

            {

            iOngoingAttr = HBufC8::NewL( ptr.Length() );

            iOngoingAttr->Des().Copy( ptr );

            iGetContentNow = ETrue;

            // just for creating provider

            if ( !ptr.Compare( KServiceProvider ) )

                {

                iGetContentNow = EFalse;

                }

            }

        if ( iOngoingAttr )

            {

            // Parsing of provider has been started.

            // This means that old provider is ready for saving 

            // if it's not first one. In that case, new provider is started.

            if ( !iOngoingAttr->Compare( KServiceProvider ) )

                {

                HandleFinishedProviderL();

                delete iOngoingAttr;

                iOngoingAttr = NULL;

               }

            }

        }

    else

        {

        ACPLOG2( "CAcpXmlHandler::OnStartElementL: error=%d", aErrorCode );

        iObserver.NotifyParsingCompleted( aErrorCode );

        }

    }

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

// CAcpXmlHandler::OnEndElementL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnEndElementL( const RTagInfo& /*aElement*/, 

    TInt aErrorCode )

    {

    if ( KErrNone == aErrorCode )

        {

        // Reset member variables.

        iGetContentNow = EFalse;

        delete iOngoingAttr;

        iOngoingAttr = NULL;

        }

    else

        {

        ACPLOG2( "CAcpXmlHandler::OnEndElementL: error=%d", aErrorCode );

        iObserver.NotifyParsingCompleted( aErrorCode );

        }

    }

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

// CAcpXmlHandler::OnContentL

// From MContentHandler.

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

//

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

    {

    if ( KErrNone == aErrorCode )

        {

        ACPLOG( "CAcpXmlHandler::OnContentL" );

        // We need to save content data if iGetContentNow is set.

        if ( iGetContentNow )

            {

            // Convert unicode data to 16-bit descriptor.

            HBufC* bytes = EscapeUtils::ConvertToUnicodeFromUtf8L( aBytes );

            // On the cleanup stack

            CleanupStack::PushL( bytes );

            ACPLOG2( "CAcpXmlHandler::OnContentL: aBytes=%S", bytes );

            // Provider name.

            if ( !iOngoingAttr->Compare( KProviderName ) )

                {

                ACPLOG( "CAcpXmlHandler::SetProviderNameL" );

                iProvider->SetProviderNameL( *bytes );

                }

            // Location of icons package.   

            else if ( !iOngoingAttr->Compare( KIconUrl ) )

                {

                ACPLOG( "CAcpXmlHandler::SetIconUrlL" );

                iProvider->SetIconUrlL( aBytes );

                }

            // Location of sis package.

            else if ( !iOngoingAttr->Compare( KSisUrl ) )

                {

                ACPLOG( "CAcpXmlHandler::SetSisUrlL" );

                iProvider->SetSisUrlL( aBytes );

                }

            // Location to create settings.    

            else if ( !iOngoingAttr->Compare( KCreateUrl ) )

                {

                ACPLOG( "CAcpXmlHandler::SetCreationUrlL" );

                iProvider->SetCreationUrlL( aBytes );

                }

            // Location to activate settings.    

            else if ( !iOngoingAttr->Compare( KActivateUrl ) )

                {

                ACPLOG( "CAcpXmlHandler::SetActivationUrlL" );

                iProvider->SetActivationUrlL( aBytes );

                }

            // Provider description.    

            else if ( !iOngoingAttr->Compare( KProviderDescription ) )

                {

                ACPLOG( "CAcpXmlHandler::SetProviderDescription" );

                iProvider->SetProviderDescriptionL( *bytes );

                }            

            // Provider type.    

            else if ( !iOngoingAttr->Compare( KProviderType ) )

                {

                ACPLOG( "CAcpXmlHandler::SetProviderType" );

                iProvider->SetProviderTypeL( *bytes );

                }            

            // Location to activate settings.    

            else if ( !iOngoingAttr->Compare( KReportUrl ) )

                {

                ACPLOG( " - Provider report url ignored" );

                }            

            // Should never happen.    

            else

                {

                User::Leave( KErrNotSupported );

                }

            CleanupStack::PopAndDestroy( bytes );

            }

        }

    else

        {

        ACPLOG2( "CAcpXmlHandler::OnContentL: error=%d", aErrorCode );

        iObserver.NotifyParsingCompleted( aErrorCode );

        }

    }

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

// CAcpXmlHandler::OnStartPrefixMappingL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnStartPrefixMappingL( 

    const RString& /*aPrefix*/, 

    const RString& /*aUri*/,

    TInt /*aErrorCode*/ )

    {

    }

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

// CAcpXmlHandler::OnEndPrefixMappingL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnEndPrefixMappingL( 

    const RString& /*aPrefix*/, 

    TInt /*aErrorCode*/ )

    {

    }

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

// CAcpXmlHandler::OnIgnorableWhiteSpaceL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnIgnorableWhiteSpaceL( 

    const TDesC8& /*aBytes*/, 

    TInt /*aErrorCode*/ )

    {

    }

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

// CAcpXmlHandler::OnSkippedEntityL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnSkippedEntityL( 

    const RString& /*aName*/, 

    TInt /*aErrorCode*/ )

    {

    }

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

// CAcpXmlHandler::OnProcessingInstructionL

// From MContentHandler.

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

//

void CAcpXmlHandler::OnProcessingInstructionL( 

    const TDesC8& /*aTarget*/, 

    const TDesC8& /*aData*/,

    TInt /*aErrorCode*/ )

    {

    }

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

// CAcpXmlHandler::OnError

// From MContentHandler.

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

//

void CAcpXmlHandler::OnError( TInt aErrorCode )

    {

    ACPLOG2( "CAcpXmlHandler::OnError: error=%d", aErrorCode );

    // Send a notification that the parsing stopped because of error.

    iObserver.NotifyParsingCompleted( aErrorCode );

    }

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

// CAcpXmlHandler::GetExtendedInterface

// From MContentHandler.

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

//

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

    {

    return NULL;

    }

// End of file.