/*

* Copyright (c) 2006 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 plugin info

*

*/

// INCLUDE FILES

#include <mpxuser.h>

#include <mpxlog.h>

#include <mpxplugininfo.h>

// CONSTANTS

_LIT8(KMPXTagMatch, "*<?>*");

_LIT8(KMPXTagEnd,"*<*?>*");

_LIT8(KMPXSupportUidsTag, "<p>");

_LIT8(KMPXPluginTypeTag, "<t>" );

_LIT8(KMPXPluginFlagTag, "<f>" );

_LIT8(KMPXPluginPriorityTag, "<i>" );

_LIT8(KMPXSupportSchemasTag,"<s>");

_LIT8(KMPXSupportExtensionsTag,"<e>");

_LIT8(KMPXSupportAppUidTag, "<a>");

_LIT8(KMPX0x, "0x");

_LIT8(KMPX0X, "0X");

const TUint8 KMPXSemicolon = ';';

const TInt KMPXTagLength = 3;

// ============================ INTERNAL CLASSES ==============================

/**

Utility class used to parse data separated by xml-style tags.

*/

class TaggedDataParser

    {

public:

    /**

     *Splits aData into xml-style tags and values, and gets aClient to process

     *each tag/value pair.

    */

    static void ParseTaggedDataL(const TDesC8& aData,

                                 MTaggedDataParserClient& aClient);

    /**

     * Converts a string to a Tint. The string may contain hex value or decimal value

    */

    static void ConvertText8ToTIntL(const TDesC8& aData, TInt& aInt);

    /**

    * Extracts elemements separated by semicolon into array descriptor

    *

    * @param aText original content to extract elements from

    * @param aArray the array to add the extracted elements to

    */

    static void ExtractIntoArrayL(const TDesC8& aText, CDesCArray*& aArray);

    /**

    * Add an item into descriptor array

    *

    * @param aItem the item to be added to the descriptor array

    * @param aArray the array to add the item to

    */

    static void AddItemIntoArrayL(TPtrC8& aItem, CDesCArray*& aArray);

    };

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

// Parser xml-styled data

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

//

void TaggedDataParser::ParseTaggedDataL(

    const TDesC8& aData,

    MTaggedDataParserClient& aClient)

    {

    TPtrC8 data(aData);

    TInt readPosition = 0;

    TBool moreData = data.Length() ? ETrue : EFalse;

    while (moreData)

        {

        // Assumes that this segment will begin with a tag

        TPtrC8 restOfData = data.Mid(readPosition);

        TInt endPos = restOfData.MatchF(KMPXTagMatch);

        if (endPos == KErrNotFound)

            User::Leave(KErrCorrupt);

        // extract the tag

        TPtrC8 tag = restOfData.Left(KMPXTagLength);

        readPosition += KMPXTagLength;

        // Find the next tag

        restOfData.Set(data.Mid(readPosition));

        endPos = restOfData.MatchF(KMPXTagMatch);

        TPtrC8 tagData;

        if (endPos == KErrNotFound)

            { // no more tag available

            endPos = restOfData.MatchF(KMPXTagEnd);

            if (endPos == KErrNotFound)

                { // If we didn't find a tag ender, we must be at the end of

                  // the data

                tagData.Set(restOfData);

                readPosition = restOfData.Length();

                }

            else

                {

                tagData.Set(restOfData.Left(endPos));

                }

            moreData = EFalse;

            }

        else

            {

            // strip the end tag from data if found

            TInt stripEndPos = restOfData.MatchF(KMPXTagEnd);

            if ( stripEndPos != KErrNotFound )

                {

                tagData.Set(restOfData.Left(stripEndPos));

                }

            else

                {

                tagData.Set(restOfData.Left(endPos));

                }

            readPosition += endPos;

            }

        aClient.ProcessTaggedDataL(tag, tagData);

        }

    }

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

// Convert text into a integer

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

//

void TaggedDataParser::ConvertText8ToTIntL(

    const TDesC8& aData,

    TInt& aInt)

    {

    // Determine whether hex or decimal then parse as such

    if (((aData.FindF(KMPX0x) == 0) || (aData.FindF(KMPX0X) == 0)) &&

        (aData.Length() >= KMPXTagLength))

        {

        // only take the characters after "0x"

        TLex8 lex(aData.Right(aData.Length()-2));

        TUint value( 0 );

        User::LeaveIfError(lex.Val(value, EHex));

        aInt = value;

        }

    else if (aData.Length() > 0)

        {

        TLex8 lex(aData);

        TInt32 value(0);

        User::LeaveIfError(lex.Val(value));

        aInt = value;

        }

    else

        {

        User::Leave(KErrCorrupt);

        }

    }

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

// Extracts elemements separated by semicolon into array descriptor

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

//

void TaggedDataParser::ExtractIntoArrayL(

    const TDesC8& aText,

    CDesCArray*& aArray)

    {

    const TUint8* p = aText.Ptr();

    TInt startPos(0);

    TInt pos(0);

    TInt len=aText.Length();

    TPtrC8 element;

    while (pos < len)

        {

        if (*(p+pos) == KMPXSemicolon)

            {

            if (pos-startPos > 0)

                {

                element.Set(p+startPos, pos - startPos);

                AddItemIntoArrayL(element, aArray);

                }

            startPos = pos + 1;

            }

        ++pos;

        }

    if (startPos < len && pos - startPos > 0)

        {// last item

        element.Set(p+startPos, pos - startPos);

        AddItemIntoArrayL(element, aArray);

        }

    }

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

// Add an item into descriptor

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

//

void TaggedDataParser::AddItemIntoArrayL(TPtrC8& aItem, CDesCArray*& aArray)

    {

    HBufC* item = MPXUser::AllocL(aItem);

    CleanupStack::PushL(item);

    //ignore leave when insert the same item

    TRAP_IGNORE(aArray->InsertIsqL(*item));

    CleanupStack::PopAndDestroy(item);

    }

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

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

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

// might leave.

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

//

EXPORT_C CMPXPluginInfo::CMPXPluginInfo()

    {

    }

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

// By default Symbian 2nd phase constructor is private.

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

//

EXPORT_C void CMPXPluginInfo::ConstructL(

    const CImplementationInformation& aData )

    {

    iPluginName = aData.DisplayName().AllocL();

    iPluginUid = aData.ImplementationUid();

    iVersion = aData.Version();

    iSupportedSchemas = new(ELeave)CDesCArrayFlat(KMPXArrayGranularity);

    iSupportedMimeTypes = new(ELeave)CDesCArrayFlat(KMPXArrayGranularity);

    iSupportedExtensions = new(ELeave)CDesCArrayFlat(KMPXArrayGranularity);

    TaggedDataParser::ExtractIntoArrayL(aData.DataType(), iSupportedMimeTypes);

    // Parse the opaque data...

    TaggedDataParser::ParseTaggedDataL(aData.OpaqueData(), *this);

    // Add plugin type into supported ids array

    TInt err=iSupportedUids.InsertInOrder(iPluginTypeUid,MPXUser::CompareUids);

    if (KErrNone!=err && KErrAlreadyExists!=err)

        { // ignore duplicated items

        User::Leave(err);

        }

    }

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

// Two-phased constructor.

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

//

CMPXPluginInfo* CMPXPluginInfo::NewL(

    const CImplementationInformation& aData )

    {

    CMPXPluginInfo* self = CMPXPluginInfo::NewLC( aData );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXPluginInfo* CMPXPluginInfo::NewLC(

    const CImplementationInformation& aData )

    {

    CMPXPluginInfo* self = new ( ELeave ) CMPXPluginInfo();

    CleanupStack::PushL( self );

    self->ConstructL( aData );

    return self;

    }

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

// Destructor

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

//

EXPORT_C CMPXPluginInfo::~CMPXPluginInfo()

    {

    delete iPluginName;

    iSupportedUids.Close();

    delete iSupportedSchemas;

    delete iSupportedMimeTypes;

    delete iSupportedExtensions;

    }

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

// Process a tagged data

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

//

EXPORT_C void CMPXPluginInfo::ProcessTaggedDataL(const TDesC8& aTag, const TDesC8& aData)

    {

    if (aTag==KMPXSupportUidsTag)

        {

        ExtractSupportedUidsL(aData);

        }

    else if (aTag==KMPXSupportAppUidTag)

        {

        TInt type(0);

        TaggedDataParser::ConvertText8ToTIntL(aData, type);

        iSupportedAppUid = TUid::Uid(type);

        MPX_DEBUG2("Plugin supported App Uid = %d", iSupportedAppUid);

        }

    else if (aTag==KMPXPluginTypeTag)

        {

        TInt type(0);

        TaggedDataParser::ConvertText8ToTIntL(aData, type);

        iPluginTypeUid = TUid::Uid(type);

        }

    else if (aTag==KMPXPluginFlagTag)

        {

        TInt value(0);

        TaggedDataParser::ConvertText8ToTIntL(aData, value);

        iFlags = (TUint)value;

        }

    else if (aTag==KMPXPluginPriorityTag)

        {

        iPriority = 0;

        TaggedDataParser::ConvertText8ToTIntL(aData, iPriority);

        }

    else if (aTag==KMPXSupportSchemasTag)

        {

        iSupportedSchemas->Reset();

        TaggedDataParser::ExtractIntoArrayL(aData, iSupportedSchemas);

        }

    else if (aTag==KMPXSupportExtensionsTag)

        {

        iSupportedExtensions->Reset();

        TaggedDataParser::ExtractIntoArrayL(aData, iSupportedExtensions);

        }

    else // let derived class to process the data

        {

        ProcessTaggedDataExL(aTag, aData);

        }

    }

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

// Default implementation of a extended tagged data

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

//

EXPORT_C void CMPXPluginInfo::ProcessTaggedDataExL(

    const TDesC8& /*aTag*/,

    const TDesC8& /*aData*/)

    {

    // Do nothing; derived class can add extended tags

    }

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

// Returns plugin's display name.

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

//

const TDesC& CMPXPluginInfo::DisplayName() const

    {

    return iPluginName ? static_cast<const TDesC&>( *iPluginName ) : KNullDesC;

    }

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

// Returns plugin's implementation uid.

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

//

EXPORT_C const TUid& CMPXPluginInfo::ImplementationUid() const

    {

    return iPluginUid;

    }

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

// Returns plugin's supported uids.

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

//

const TArray<TUid> CMPXPluginInfo::SupportedUids() const

    {

    return iSupportedUids.Array();

    }

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

// Returns plugin's plugin type.

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

//

const TUid& CMPXPluginInfo::PluginType() const

    {

    return iPluginTypeUid;

    }

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

// Returns Plugin's supported App Uid.

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

//

const TUid& CMPXPluginInfo::SupportedAppUid() const

    {    

    return iSupportedAppUid;

    }

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

// Returns plugin's view priority.

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

//

TInt CMPXPluginInfo::Priority() const

    {

    return iPriority;

    }

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

// Extracts plugin supported Uids from data.

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

//

void CMPXPluginInfo::ExtractSupportedUidsL(const TDesC8& aData)

    {

    iSupportedUids.Reset();

    ExtractUidsFromTextL( aData, iSupportedUids );

    }

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

// Parse a text string to extract a list of UIDs

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

//

EXPORT_C void CMPXPluginInfo::ExtractUidsFromTextL( const TDesC8& aData,

                                                    RArray<TUid>& aArray )

    {

    aArray.Reset();

    const TUint8* p = aData.Ptr();

    TInt startPos(0);

    TInt pos(0);

    TInt len=aData.Length();

    TPtrC8 element;

    TInt err(KErrNone);

    while (pos < len)

        {

        if (*(p+pos) == KMPXSemicolon)

            {

            if (pos-startPos > 0)

                {

                element.Set(p+startPos, pos - startPos);

                TInt val(0);

                TaggedDataParser::ConvertText8ToTIntL(element, val);

                err = aArray.InsertInOrder(TUid::Uid(val),

                                           MPXUser::CompareUids);

                if (KErrNone!=err && KErrAlreadyExists!=err)

                    { // ignore duplicated items

                    User::Leave(err);

                    }

                }

            startPos = pos + 1;

            }

        ++pos;

        }

    if (startPos < len && pos - startPos > 0)

        {// last item

        element.Set(p+startPos, pos - startPos);

        TInt val(0);

        TaggedDataParser::ConvertText8ToTIntL(element, val);

        aArray.AppendL(TUid::Uid(val));

        }

    }

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

// Return supported mime types

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

//

const CDesCArray& CMPXPluginInfo::SupportedMimeTypes() const

    {

    return *iSupportedMimeTypes;

    }

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

// Return supported extensions

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

//

const CDesCArray& CMPXPluginInfo::SupportedExtensions() const

    {

    return *iSupportedExtensions;

    }

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

// Return supported schemas

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

//

const CDesCArray& CMPXPluginInfo::SupportedSchemas() const

    {

    return *iSupportedSchemas;

    }

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

// CMPXPluginInfo::SupportUids

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

//

TBool CMPXPluginInfo::SupportUids(const TArray<TUid>& aUids) const

    {

    return MPXUser::CompareOrderedUidArrays(iSupportedUids.Array(), aUids)>=0;

    }

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

// CMPXPluginInfo::Flags

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

//

EXPORT_C TUint CMPXPluginInfo::Flags() const

    {

    return iFlags;

    }

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

// CMPXPluginInfo::Flags

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

//

TInt CMPXPluginInfo::Version() const

    {

    return iVersion;

    }

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

// CMPXPluginInfo::ReferenceCount

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

//

TInt& CMPXPluginInfo::ReferenceCount()

    {

    return iReferenceCount;

    }