--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpx/commonframework/common/src/mpxplugininfo.cpp Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,560 @@
+/*
+* 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;
+ }
+
+// ----------------------------------------------------------------------------
+// CMPXPluginInfo::ComparePluginInfoByPriority
+// ----------------------------------------------------------------------------
+//
+TInt CMPXPluginInfo::ComparePluginInfoByPriority(
+ const CMPXPluginInfo& aPluginInfo1,
+ const CMPXPluginInfo& aPluginInfo2)
+ {
+ TInt ret(0);
+ if (aPluginInfo1.Priority() > aPluginInfo2.Priority())
+ {
+ ret=-1;
+ }
+ else if (aPluginInfo1.Priority() < aPluginInfo2.Priority())
+ {
+ ret=1;
+ }
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// Extracts elemements separated by semicolon into array descriptor
+// ----------------------------------------------------------------------------
+//
+EXPORT_C void CMPXPluginInfo::ExtractIntoArrayL(const TDesC8& aText,
+ CDesCArray*& aArray)
+ {
+ TaggedDataParser::ExtractIntoArrayL(aText, aArray);
+ }
+
+// End of File