--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_applicationmanager/tsrc/dev/tappmanprovidernegativetest/src/txmlconvertor.cpp Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,582 @@
+/*
+* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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: ?Description
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+
+#include <LiwServiceHandler.h>
+#include <Liwbufferextension.h>
+#include <gmxmldocument.h>
+#include <gmxmlelement.h>
+#include <gmxmlcharacterdata.h>
+#include <charconv.H>
+#include <gmxmltext.h>
+
+#include "txmlconvertor.h"
+
+#include <f32file.h>
+#include <e32des16.h>
+#include <e32base.h>
+
+#include "tprovidertestobserver.h"
+
+_LIT8(KErrorCode,"ErrorCode");
+
+
+// Define constants
+const TInt KTYPE_ID_LEN = 7;
+const TInt KENTRY_LEN = 5;
+const TInt KINT_LEN = 3;
+const TInt KBOOL_LEN = 4;
+const TInt KDATE_LEN = 4;
+const TInt KFLOAT_LEN = 5;
+const TInt KMAX_LEN = 255;
+const TInt KSTRING_LEN = 8;
+const TInt KLIST_LEN = 4;
+const TInt KITER_LEN = 8;
+const TInt KMAP_LEN = 3;
+const TInt KKEY_LEN = 3;
+const TInt KNAME_LEN = 4;
+const TInt KPARAMS_LEN = 6;
+const TInt KPARAM_LEN = 5;
+const TInt KDateLen = 25;
+
+const TInt KMaxOutputLen = 1000;
+
+
+
+_LIT(KAttribute, "type_id");
+_LIT(KKeyAttribute, "name");
+_LIT(KInt, "int");
+_LIT(KFloat, "float");
+_LIT(KString, "string");
+_LIT(KString8, "string8");
+_LIT(KList, "list");
+_LIT(KMap, "map");
+_LIT(KKey, "key");
+_LIT(KBool, "bool");
+_LIT(KDate, "date");
+
+_LIT(KEntry, "entry");
+_LIT(KIterator, "iterator");
+_LIT(KOpenTag, "<");
+_LIT(KFinalCloseTag, "/>");
+_LIT(KCloseTag, ">");
+_LIT(KOpenTagSlash, "</");
+_LIT(KParams, "params");
+_LIT(KParam, "param");
+_LIT(KNameAttribute, "name");
+_LIT(KSTDDATE, "19700001:000000.000000");
+
+
+
+// Converts the output params from LIW specific data type to xml based flash
+// specific data type.
+
+void CXmlConvertor::BuildOutputTreeL(CLiwGenericParamList& aOutParamList,TPtrC& aPtr)
+ {
+ CMDXMLDocument* pDocNode = CMDXMLDocument::NewLC();
+ if (pDocNode)
+ {
+ TBuf<KPARAMS_LEN> paramsNode(KParams);
+ CMDXMLElement* pParamsNode = CMDXMLElement::NewLC(ETrue,pDocNode,paramsNode);
+
+ if (pParamsNode)
+ {
+ for(TInt i=0; i < aOutParamList.Count(); ++i)
+ {
+ //create <param name=""/> tag
+ TBuf<KPARAM_LEN> paramNode(KParam);
+ CMDXMLElement* pParamNode = CMDXMLElement::NewLC(ETrue,pDocNode,paramNode);
+ if (pParamNode)
+ {
+ TBuf<KMAX_LEN> paramName;
+ TLiwGenericParam outParam = aOutParamList[i];
+
+ if(outParam.Name().Length()!=0)
+ {
+ paramName.Copy(outParam.Name());
+ }
+ else
+ {
+ TInt semID = outParam.SemanticId();
+ const TDesC8& strParam = this->GetParamAsString(semID);
+ paramName.Copy(strParam);
+ }
+
+ TBuf<KNAME_LEN> nameAttr(KKeyAttribute);
+ //Create an attribute "name"
+ pParamNode->SetAttributeL(nameAttr,paramName);
+
+ pParamsNode->AppendChild(pParamNode);
+
+ AppendOutParamL(pDocNode,pParamNode,outParam.Value());
+ CleanupStack::Pop(pParamNode);
+ }
+ }
+ // Convert the output to string.
+ ToStringL(pParamsNode, aPtr);
+
+ CleanupStack::PopAndDestroy(pParamsNode);
+ }
+ CleanupStack::PopAndDestroy(pDocNode);
+ }
+ }
+
+
+// Converts the TGenericParamId passed by the service provider
+// to string, as we can pass only string values to flash content.
+const TDesC8& CXmlConvertor::GetParamAsString(TGenericParamId aParamID)
+ {
+ switch(aParamID)
+ {
+ case EGenericParamError:
+ {
+ return KErrorCode();
+ }
+
+ //Convert other generic param IDs if required
+ default:
+ break;
+ }
+ return KNullDesC8();
+ }
+
+
+
+
+
+
+
+//Output parameter processing
+// Appends the value in TLiwVariant to the XML tree.
+void CXmlConvertor::AppendOutParamL(CMDXMLDocument* aDocNode, CMDXMLElement* aParentNode,
+ const TLiwVariant& aParamVar)
+ {
+ if (aDocNode && aParentNode)
+ {
+ TBuf<KTYPE_ID_LEN> typeIdAttr(KAttribute);
+ TBuf<KENTRY_LEN> entryNode(KEntry);
+ CMDXMLElement* pEntryNode = CMDXMLElement::NewL(ETrue,aDocNode,entryNode);
+ if (pEntryNode)
+ {
+ CleanupStack::PushL(pEntryNode);
+
+ if(aParamVar.TypeId()==EVariantTypeTInt32)
+ {
+ //Form attribute "name" with value "int"
+ TBuf<KINT_LEN> typeIdValue(KInt);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsTInt32()
+ CMDXMLText* pValueNode = CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ TInt intValue = aParamVar.AsTInt32();
+ TInt len = GetLengthToStoreInt(intValue);
+ HBufC* hInt = HBufC::NewLC(len+1);
+ TPtr intPtr(hInt->Des());
+ intPtr.Num(intValue);
+
+ pValueNode->SetDataL(intPtr);
+ pEntryNode->AppendChild(pValueNode);
+
+ CleanupStack::PopAndDestroy(hInt);
+ CleanupStack::Pop(pValueNode);
+ }
+ else if(aParamVar.TypeId()==EVariantTypeTBool)
+ {
+ //Form attribute "name" with value "bool"
+ TBuf<KBOOL_LEN> typeIdValue(_L("bool"));
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsTBool()
+ CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ TBuf<KMAX_LEN> value;
+ value.Num(aParamVar.AsTBool());
+
+ pValueNode->SetDataL(value);
+ pEntryNode->AppendChild(pValueNode);
+ CleanupStack::Pop(pValueNode);
+ }
+ else if(aParamVar.TypeId()==EVariantTypeDesC8)
+ {
+ //Form attribute "name" with value "string"
+ TBuf<KSTRING_LEN> typeIdValue(KString8);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsDes()
+ CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ TPtrC8 pValue;
+ aParamVar.Get(pValue);
+ HBufC* heapBuffer = HBufC::NewL( pValue.Length() );
+ CleanupStack::PushL( heapBuffer );
+ TPtr value( heapBuffer->Des() );
+ value.Copy( pValue );
+ pValueNode->SetDataL(value);
+ CleanupStack::PopAndDestroy();
+
+ pEntryNode->AppendChild(pValueNode);
+ CleanupStack::Pop(pValueNode);
+ }
+
+ else if(aParamVar.TypeId()==EVariantTypeTTime)
+ {
+ //Form attribute "name" with value "date"
+ TBuf<KDATE_LEN> typeIdValue(_L("date"));
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsTTime()
+ CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ // Convert the date as ActionScript requires that the date be passed as
+ // milliseconds since midnight January 1, 1970.
+ TBuf<KDateLen> dateBuf(KSTDDATE);
+ TTime std(dateBuf);
+
+ TTime timeVal = aParamVar.AsTTime();
+
+ //Convert microseconds to milliseconds.
+ TTimeIntervalMicroSeconds timeMS = timeVal.MicroSecondsFrom(std);
+ TInt64 timeInt = timeMS.Int64();
+ timeInt = timeInt/1000;
+
+ TInt64 len = GetLengthToStoreInt64(timeInt);
+ HBufC* hInt = HBufC::NewLC(len);
+ TPtr intPtr(hInt->Des());
+ intPtr.Num(timeInt);
+
+ pValueNode->SetDataL(intPtr);
+
+ pEntryNode->AppendChild(pValueNode);
+
+ CleanupStack::PopAndDestroy(hInt);
+ CleanupStack::Pop(pValueNode);
+ }
+ else if(aParamVar.TypeId()==EVariantTypeTReal)
+ {
+ //Form attribute "name" with value "float"
+ TBuf<KFLOAT_LEN> typeIdValue(KFloat);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsReal()
+ CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ TRealFormat format;
+ format.iType = KRealFormatGeneral;
+
+ TBuf<KMAX_LEN> value;
+ value.Num(aParamVar.AsTReal(),format);
+
+
+ pValueNode->SetDataL(value);
+ pEntryNode->AppendChild(pValueNode);
+ CleanupStack::Pop(pValueNode);
+ }
+ else if(aParamVar.TypeId()==EVariantTypeDesC)
+ {
+ //Form attribute "name" with value "string"
+ TBuf<KSTRING_LEN> typeIdValue(KString);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ //Create text node with value equivalent to aParamVar.AsDes()
+ CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);
+ CleanupStack::PushL(pValueNode);
+
+ TPtrC pValue=aParamVar.AsDes();
+ pValueNode->SetDataL(pValue);
+
+ pEntryNode->AppendChild(pValueNode);
+ CleanupStack::Pop(pValueNode);
+ }
+ else if( aParamVar.TypeId()==EVariantTypeList)
+ {
+ //Form attribute "name" with value "list"
+ TBuf<KLIST_LEN> typeIdValue(KList);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+ const CLiwList* pList=aParamVar.AsList();
+ if ( pList )
+ {
+ CleanupStack::PushL(const_cast<CLiwList*>(pList));
+ for(TInt l=0; l != pList->Count(); ++l)
+ {
+ TLiwVariant listEntry;
+ pList->AtL(l,listEntry);
+ this->AppendOutParamL(aDocNode,pEntryNode,listEntry);
+ listEntry.Reset();
+ }
+ CleanupStack::Pop(const_cast<CLiwList*>(pList));
+ }
+ }
+ else if(aParamVar.TypeId()==EVariantTypeIterable)
+ {
+ //Handling is same as that of list, accessor
+ //method is different (AsIterable)
+ //Form attribute "name" with value "iterator"
+
+ TBuf<KITER_LEN> typeIdValue(KIterator);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+
+ CLiwIterable* pIter=aParamVar.AsIterable();
+ if (pIter)
+ {
+ CleanupStack::PushL(pIter);
+
+ TLiwVariant entry;
+ while(EFalse != pIter->NextL(entry))
+ {
+ this->AppendOutParamL(aDocNode,pEntryNode,entry);
+ entry.Reset();
+ }
+ entry.Reset();
+ CleanupStack::Pop(pIter);
+ }
+ }
+ else if(aParamVar.TypeId()==EVariantTypeMap)
+ {
+ //Form attribute "name" with value "list"
+ TBuf<KMAP_LEN> typeIdValue(KMap);
+ pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);
+ const CLiwMap* pMap=aParamVar.AsMap();
+ if ( pMap )
+ {
+ CleanupStack::PushL(const_cast<CLiwMap*>(pMap));
+ for(TInt m=0; m!=pMap->Count();++m)
+ {
+ TBuf8<KMAX_LEN> mapKey;
+ pMap->AtL(m,mapKey);
+ TBuf<KMAX_LEN> mapKey16;
+ mapKey16.Copy(mapKey);
+
+ //Add key node as child of entry node
+ TBuf<KKEY_LEN> keyNode(KKey);
+ TBuf<KNAME_LEN> nameAttr(KKeyAttribute);
+ CMDXMLElement* pKeyNode = CMDXMLElement::NewL(ETrue,aDocNode,keyNode);
+ if (pKeyNode)
+ {
+ CleanupStack::PushL(pKeyNode);
+ pKeyNode->SetAttributeL(nameAttr,mapKey16);
+ pEntryNode->AppendChild(pKeyNode);
+
+ TLiwVariant fndEntry;
+ TBool found = pMap->FindL(mapKey,fndEntry);
+ if ( found )
+ {
+ this->AppendOutParamL(aDocNode,pKeyNode,fndEntry);
+ fndEntry.Reset();
+ }
+ CleanupStack::Pop(pKeyNode);
+ }
+ }
+ CleanupStack::Pop(const_cast<CLiwMap*>(pMap));
+ }
+ }
+ aParentNode->AppendChild(pEntryNode);
+ CleanupStack::Pop(pEntryNode);
+ }
+ }
+ }
+
+
+
+
+// The ouput XML tree contains the output params. This function converts the output to the
+// string representation of the xml based flash specific data type.
+void CXmlConvertor::ToStringL(CMDXMLElement* aRootNode,TPtrC& aPtr)
+ {
+ delete iOutputBuffer;
+ iOutputBuffer = NULL;
+ iOutputBuffer = HBufC::NewL(KMaxOutputLen);
+ WriteElementL(aRootNode);
+ aPtr.Set(*iOutputBuffer);
+ }
+
+// This function writes the contents of the XML node to the output.
+void CXmlConvertor::WriteElementL(CMDXMLElement* aElemNode)
+ {
+ if (aElemNode)
+ {
+ //write start element tag i.e <element_name>
+ WriteStartElementTagL(aElemNode);
+ if(aElemNode->HasChildNodes()==0)
+ {
+ AppendStringL(KFinalCloseTag);
+ return;
+ }
+ else //write end element tag i.e </element_name>
+ {
+ AppendStringL(KCloseTag);
+
+ for(CMDXMLNode* pCurrNode = aElemNode->FirstChild();
+ NULL != pCurrNode;
+ pCurrNode = pCurrNode->NextSibling()
+ )
+ {
+ if(CMDXMLNode::EElementNode==pCurrNode->NodeType())
+ {
+ WriteElementL((CMDXMLElement*)pCurrNode);
+ }
+ else if(CMDXMLNode::ETextNode==pCurrNode->NodeType())
+ {
+ AppendStringL(((CMDXMLCharacterData*)pCurrNode)->Data());
+ }
+ }
+
+ WriteEndElementTagL(aElemNode);
+ }
+ }
+ }
+
+ // This function writes the start element tag and the attributes of the node
+// to the output.
+void CXmlConvertor::WriteStartElementTagL(CMDXMLElement* aElemNode)
+ {
+ if (aElemNode)
+ {
+ AppendStringL(KOpenTag); //<
+ AppendStringL(aElemNode->NodeName()); //<element_name
+ if(aElemNode->NumAttributes()>0)
+ {
+ WriteAttributeTagL(aElemNode);
+ }
+ }
+ }
+
+ // This function writes the end element tag to the output.
+void CXmlConvertor::WriteEndElementTagL(CMDXMLElement* aElemNode)
+ {
+ if(aElemNode && aElemNode->HasChildNodes())
+ {
+ AppendStringL(KOpenTagSlash);
+ AppendStringL(aElemNode->NodeName());
+ AppendStringL(KCloseTag);
+ }
+ else
+ {
+ AppendStringL(KFinalCloseTag);
+ }
+ }
+
+
+ // This function writes the attributes of the node to the output.
+void CXmlConvertor::WriteAttributeTagL(CMDXMLElement* aElemNode)
+ {
+ //Add a space before adding attr
+ if(aElemNode && aElemNode->NumAttributes()>0)
+ {
+ TPtrC attributeValue;
+ TPtrC attributeName;
+ for(TInt i=0; i!=aElemNode->NumAttributes(); ++i)
+ {
+ AppendStringL(KSingleSpace);
+ aElemNode->AttributeDetails(i, attributeName, attributeValue);
+ AppendStringL(attributeName);
+ AppendStringL(KEqualSign);
+
+ AppendStringL(KQuotation);
+ AppendStringL(attributeValue);
+ AppendStringL(KQuotation);
+ }
+ }
+ }
+
+
+
+ // Appends the output to the output buffer.
+void CXmlConvertor::AppendStringL(const TDesC& aStr)
+ {
+ TPtr bufPtr(iOutputBuffer->Des());
+ TInt maxLen = bufPtr.MaxLength();
+
+ TInt outLen = iOutputBuffer->Length();
+ TInt strLen = aStr.Length();
+
+ TInt remLen = maxLen - outLen;
+ // ReAlloc if more space is required.
+ if ( strLen > remLen)
+ {
+ iOutputBuffer = iOutputBuffer->ReAllocL(maxLen+strLen);
+ }
+ TPtr outPtr(iOutputBuffer->Des());
+ outPtr.Append(aStr);
+ }
+
+
+// Calculates the length of the string needed to store the integer.
+TInt CXmlConvertor::GetLengthToStoreInt(TInt aNum)
+ {
+ TInt num = Abs(aNum);
+ TInt len = 0;
+ while(num)
+ {
+ len++;
+ num=num/10;
+ }
+ return len;
+ }
+
+
+// Calculates the length of the string needed to store the 64 bit integer.
+TInt64 CXmlConvertor::GetLengthToStoreInt64(TInt64 aNum)
+ {
+ TInt64 len = 0;
+ while(aNum)
+ {
+ len++;
+ aNum=aNum/10;
+ }
+ return len;
+ }
+
+
+
+CXmlConvertor:: ~CXmlConvertor()
+ {
+ if (iOutputBuffer)
+ {
+ delete iOutputBuffer;
+ iOutputBuffer = NULL;
+ }
+ }
+
+
+CXmlConvertor* CXmlConvertor:: NewL()
+ {
+ CXmlConvertor* temp = new(ELeave)CXmlConvertor();
+ CleanupStack::PushL(temp);
+ temp->ConstructL();
+ CleanupStack::Pop(temp);
+ return temp;
+ }
+
+
+void CXmlConvertor:: ConstructL()
+ {
+
+ }
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+// None
+
+// End of File