/*

* Copyright (c) 2002-2005 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:        

*

*/

// INCLUDE FILES

#include <xml/attribute.h> // From syslibs, needed for RAttributeArray

#include <SenXmlReader.h>

#include <SenXmlConstants.h>

#include <SenXmlUtils.h>

#include <MSenContentHandlerClient.h>

#include "senxmldebug.h"

#ifdef EKA2

    #ifndef __SERIES60_30__

        // S60 3.1 or newer

        #include <xml/matchdata.h>

    #endif

#else

    // Use fss with S60 2nd edition FP3 (2.8) - temp file is needed with expat

    #include <s32file.h> // filestream

#endif

// DEBUG:

#include "sendebug.h"

using namespace Xml;

namespace

    {

    const TInt KArraySize = 128;

    typedef struct

        {

        CSenXmlReader*  ipReader;

        TInt            iEnabledFeature;

        } TReaderData;

    }

_LIT8(KDefaultMimeType, "");  // Expat is made default, so don't have to give mime type

EXPORT_C CSenXmlReader* CSenXmlReader::NewL()

    {

    CSenXmlReader* pNew = NewLC();

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewLC()

    {

    CSenXmlReader* pNew = new (ELeave) CSenXmlReader(KSenDefaultParserFeature);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(KDefaultMimeType);// KXmlParserMimeType : Defaulted to Expat

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewL(TInt aParserFeature)

    {

    CSenXmlReader* pNew = NewLC(aParserFeature);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewLC(TInt aParserFeature)

    {

    CSenXmlReader* pNew = new (ELeave) CSenXmlReader(aParserFeature);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(KDefaultMimeType);// KXmlParserMimeType : Defaulted to Expat

    if(aParserFeature<0)

        {

        User::Leave(KErrArgument);

        }

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewL(const TDesC8& aParserMimeType)

    {

    CSenXmlReader* pNew = NewLC(aParserMimeType);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewLC(const TDesC8& aParserMimeType)

    {

    CSenXmlReader* pNew = new (ELeave) CSenXmlReader(KSenDefaultParserFeature);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aParserMimeType);

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewL(const TDesC8& aParserMimeType,

                                            TInt aParserFeature)

    {

    CSenXmlReader* pNew = NewLC(aParserMimeType, aParserFeature);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenXmlReader* CSenXmlReader::NewLC(const TDesC8& aParserMimeType,

                                             TInt aParserFeature)

    {

    CSenXmlReader* pNew = new (ELeave) CSenXmlReader(aParserFeature);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aParserMimeType);

    if(aParserFeature<0)

        {

        User::Leave(KErrArgument);

        }

    return pNew;

    }

EXPORT_C CSenXmlReader::CSenXmlReader(TInt aEnabledFeature)

:

iParser(NULL),

iContentHandler(NULL),

ipNsPrefixes(NULL),

ipNsUris(NULL),

iEnabledFeature(aEnabledFeature)

    {

    }

EXPORT_C CSenXmlReader::~CSenXmlReader()

    {

    delete iParser;

    delete ipNsPrefixes;

    delete ipNsUris;

    iStringPool.Close();

    }

#if defined( __SERIES60_30__ )

void CSenXmlReader::ConstructL(const TDesC8& aParserMimeType)

    {

    if(aParserMimeType.Length()==0)

        {

        // Use default MIME type

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

        }

    else

        {

        // Pass aParserMimeType

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

        }

    iParser->EnableFeature(iEnabledFeature);

    iStringPool.OpenL();

    }

#else

void CSenXmlReader::ConstructL(const TDesC8& aParserMimeType)

    {

    CMatchData* pMatchData = CMatchData::NewL();

    CleanupStack::PushL(pMatchData);

    if(aParserMimeType.Length()==0)

        {

        // Use default MIME type and variant

        // for this parser instance (text/xml)

        pMatchData->SetMimeTypeL(KXmlParserMimeType);

        }

    else

        {

        // Use specified aParserMimeType:

        pMatchData->SetMimeTypeL(aParserMimeType);

	    // Set the default variant type (libxml2)

		pMatchData->SetVariantL(KXmlVariant);             

        }

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

    CleanupStack::PopAndDestroy(pMatchData);

    iParser->EnableFeature(iEnabledFeature);

    iStringPool.OpenL();

    }

#endif

EXPORT_C void CSenXmlReader::SetContentHandler(

                                    MSenContentHandlerClient& aContentHandler)

    {

    iContentHandler = &aContentHandler;

    }

#ifdef EKA2 

// In S60 3rd edition platform there is a fixed version of expat parser which

// can parse XML documents which size is 2048 bytes or greater. The previous 

// versions crashed with larger documents.

EXPORT_C void CSenXmlReader::ParseL(const TDesC8& aBuff)

    {

    CleanUp();

#if defined(__SERIES60_30__)

    RecreateParserL();

#endif // __SERIES_30__ defined

    // Note(!): Store the currently enabled feature, since the same member

    // is used to carry a possible error code from OnErrorL() callback:

    TInt feature(iEnabledFeature);

    TReaderData* pData = new (ELeave) TReaderData;

    pData->ipReader         = this;

    pData->iEnabledFeature  = iEnabledFeature;

    CleanupStack::PushL( TCleanupItem( CSenXmlReader::CleanupParser, pData ) );

    // Parse the XML document:

    iParser->ParseL(aBuff);

    CleanupStack::Pop();

    delete pData;

    iParser->ParseEndL(); // Enables Symbian XML framework errors to propagete OnErrorL() callback

    CleanUp();

    // Check if iEnabledFeature member was used to carry an error from OnErrorL() callback..

    if (iEnabledFeature < 0)

        {

        TInt error(iEnabledFeature);

        SENDEBUG((_L("CSenXmlReader::ParserL: leaving (%d)"), error));

        // Switch back the originally enabled feature

        iEnabledFeature = feature;

        User::Leave(error);

        }

    iContentHandler->EndDocument();

    }

#else 

EXPORT_C void CSenXmlReader::ParseL(const TDesC8& aBuff)

    {

    // In S60 2nd edition FP3 (2.8) platform a temp file has to be used, since the

    // underlying expat parser would crash when parsing a document which consists 

    // of more that 2048 bytes of XML.

    if (aBuff.Length() > 2048) // there is 2048 bytes limitation in expat parser!

        {

        SENDEBUG_L("CSenXmlReader::ParseL(): parsing over 2048 bytes of XML (EKA1)");

        SENDEBUG((_L("- document size: %d bytes."), aBuff.Length() ));

        // Parse large XML documents using file server

        RFs fss;

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

        CleanupClosePushL(fss);

        // Now create a new temp file in the specified path using unique 

        // file name which is generated by the file server. Since file 

        // server is not responsible to delete this file, it must be done 

        // after parsing is finished.

        // Path for temp file

        _LIT(KFilePath, "c:\\");

        // Stores the temp file name when fileOutStream.Temp() returns:

        TFileName tempFilename; 

        // Try to generate new temporary file, leave if it failes:

        RFileWriteStream fileOutStream;

        User::LeaveIfError(fileOutStream.Temp(fss, KFilePath, tempFilename, EFileWrite));

        CleanupClosePushL(fileOutStream);

        SENDEBUG((_L("CSenXmlReader::ParseL(): used temp file name: '%S'"), &tempFilename));

        // Write XML document into the file:

        fileOutStream.WriteL(aBuff);

        // fileOutStream.Close(). Must be done prior ParseL()!

        CleanupStack::PopAndDestroy(); 

        // Parse the file:

        ParseL(fss, tempFilename);

        // Now delete the temporary file (when it is not in locked in parser's use)

        fss.Delete(tempFilename);

        // Finally close the file server session

        CleanupStack::PopAndDestroy(); // fss.Close()

        SENDEBUG_L("CSenXmlReader::ParseL() successfully parsed > 2048 bytes of XML.");

        }

    else

        {

        // Smaller documents may be parsed normally, even with older versions

        // of Symbian XML framework's expat parser.

        CleanUp();

#if defined(__SERIES60_30__)

    RecreateParserL();

#endif // __SERIES_30__ defined

        TInt feature(iEnabledFeature);

        TReaderData* pData = new (ELeave) TReaderData;

        pData->ipReader         = this;

        pData->iEnabledFeature  = iEnabledFeature;

        CleanupStack::PushL( TCleanupItem( CSenXmlReader::CleanupParser, pData ) );

        // Parse the XML document:

        iParser->ParseL(aBuff);

        CleanupStack::Pop();

        delete pData;

        iParser->ParseEndL(); // Enables Symbian XML framework errors to propagete OnErrorL() callback

        CleanUp();

        if (iEnabledFeature < 0) 

            {

            TInt error(iEnabledFeature);

            iEnabledFeature = feature;

            SENDEBUG((_L("CSenXmlReader::ParserL: leaving (%d)"), iEnabledFeature));

            User::Leave(error);

            }

        iContentHandler->EndDocument();

        }

    }

#endif // not EKA2 

EXPORT_C void CSenXmlReader::ParseL(RFs &aRFs, const TDesC& aFileToParse)

    {

    CleanUp();

#if defined(__SERIES60_30__)

    RecreateParserL();

#endif // __SERIES_30__ defined

    TInt feature(iEnabledFeature);

    TReaderData* pData = new (ELeave) TReaderData;

    pData->ipReader         = this;

    pData->iEnabledFeature  = iEnabledFeature;

    CleanupStack::PushL( TCleanupItem( CSenXmlReader::CleanupParser, pData ) );

    // Parse the XML document:

    Xml::ParseL(*iParser, aRFs, aFileToParse); 

    // Note: Xml::ParseL calls ParseL() and ParseEndL() internally:

    CleanupStack::Pop();

    delete pData;

    CleanUp();

    if(iEnabledFeature < 0) 

        {

        TInt leaveError = iEnabledFeature;

        iEnabledFeature = feature;

        User::Leave(leaveError);

        }

    iContentHandler->EndDocument();

    }

// protected helper

void CSenXmlReader::RecreateParserL()

    {

    delete iParser;

    iParser = NULL;

    delete ipNsPrefixes;

    ipNsPrefixes = NULL;

    delete ipNsUris;

    ipNsUris = NULL;

#if defined(__SERIES60_30__)

    // Use default MIME type

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

#else

    CMatchData* pMatchData = CMatchData::NewL();

    CleanupStack::PushL(pMatchData);

    pMatchData->SetMimeTypeL(KXmlParserMimeType);

    pMatchData->SetVariantL(KXmlVariant);

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

    CleanupStack::PopAndDestroy(pMatchData);

#endif

    iParser->EnableFeature(iEnabledFeature);

    }

void CSenXmlReader::OnStartDocumentL(

                                const RDocumentParameters& /* aDocParam */,

                                TInt /* aErrorCode */)

    {

    if(!iContentHandler)

        {

        SENDEBUG_L("OnStartDocumentL: KErrSenXmlContentHandlerNotSet");

        User::Leave(KErrSenXmlContentHandlerNotSet);

        }

    iContentHandler->StartDocument();

    }

void CSenXmlReader::OnEndDocumentL(TInt /* aErrorCode */)

    {

    if(!iContentHandler)

        {

        SENDEBUG_L("OnEndDocumentL: KErrSenXmlContentHandlerNotSet");

        User::Leave(KErrSenXmlContentHandlerNotSet);

        }

    iContentHandler->EndDocument();

    }

void CSenXmlReader::OnStartElementL(const RTagInfo& aElement,

                             const RAttributeArray& aAttributes,

                             TInt /* aErrorCode */)

    {

    if(!iContentHandler)

        {

        SENDEBUG_L("OnStartElementL: KErrSenXmlContentHandlerNotSet");

        User::Leave(KErrSenXmlContentHandlerNotSet);

        }

    const TPtrC8 localName = aElement.LocalName().DesC();

    const TPtrC8 nsUri = aElement.Uri().DesC();

    const TPtrC8 prefix = aElement.Prefix().DesC();

    TPtrC8 qualifiedName = localName;

    if (prefix != KNullDesC8)

        {

        HBufC8* pQName = HBufC8::NewLC(prefix.Length()+localName.Length()+

                                        KSenColon().Length());

        TPtr8 qName = pQName->Des();

        qName.Append(prefix);

        qName.Append(KSenColon);

        qName.Append(localName);

        qualifiedName.Set(qName);

        }

    if(ipNsPrefixes)

        {

        // there are namespaces to declare!

        // make a new array for all attributes including namespace (to be added)

        RAttributeArray attributesAndNamespaces;

        CleanupClosePushL(attributesAndNamespaces);

        TInt nsDeclarationCount(ipNsPrefixes->Count());

        for(TInt i=0; i<nsDeclarationCount; i++)

            {

            // open and take ownership of RString - xmlnsAttrPrefix

            RAttribute nsAttribute;

            //CleanupClosePushL(nsAttribute);

            TPtrC8 nsPrefix = ipNsPrefixes->MdcaPoint(i);

            TPtrC8 nsURI =  ipNsUris->MdcaPoint(i);

            if (nsPrefix != KNullDesC8)

                {

                nsAttribute.Open(iStringPool.OpenStringL(nsURI), 

                                iStringPool.OpenStringL(KSenXmlns()),

                                iStringPool.OpenStringL(nsPrefix),

                                iStringPool.OpenStringL(nsURI) );

                }

            else

                {

                nsAttribute.Open(iStringPool.OpenStringL(nsURI),

                            iStringPool.OpenStringL(KNullDesC8()),

                            iStringPool.OpenStringL(KSenXmlns()),

                            iStringPool.OpenStringL(nsURI) );

                }   

            // append the namespace attribute (declaration)

            CleanupClosePushL(nsAttribute);

            attributesAndNamespaces.AppendL(nsAttribute);

            CleanupStack::Pop(); // nsAttribute

            }

        // the ns declarations have been done using NON-CANONIZING method

        delete ipNsPrefixes;

        ipNsPrefixes = NULL;

        delete ipNsUris;

        ipNsUris = NULL;

        // append all other ("real") attributes

        TInt count(aAttributes.Count());

        for(TInt a=0; a<count; a++)

            {

            attributesAndNamespaces.AppendL(const_cast <RAttribute&> (aAttributes[a]).Copy());

            }

        // now give the stream content forward to the interested handler object.

        // we have successfully added the namespace declaration as NON-canonized(!)

        // attribute (if conditions have been met).

        iContentHandler->StartElement(nsUri, localName, qualifiedName, attributesAndNamespaces);

        // close the copied attributes previously added into this array as copies

        count = attributesAndNamespaces.Count();

        for(TInt j=0; j<count; j++)

            {

            attributesAndNamespaces[j].Close();

            }

        // close the actual array

        CleanupStack::PopAndDestroy(); // attributesAndNamespaces.Close();

        }

    else

        {

        // give the original attributes to content handler (no new namespaces declared in attrs)

        iContentHandler->StartElement(nsUri, localName, qualifiedName, aAttributes);

        }

    // delete qualified element name, if one was allocated

    if (prefix != KNullDesC8)

        {

        CleanupStack::PopAndDestroy(); // pQName

        }