// Copyright (c) 1997-2009 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 <versit.h>
#include <vprop.h>
#include <vutil.h>
#include <s32mem.h>
#include <concnf.h>
#include <confndr.h>
#include <conlist.h>
#include <charconv.h>
#include <utf.h>
#include <vcal.h>
#include <vcard.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <vpropbinaryfile.h>
#include "versit_internal.h"
#endif
// User includes
#include <vstaticutils.h>
#include <vobserv.h>
#include "vpbapplugin.h"
// Constants
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
const TInt KRandomnumberlen = 5;
const TInt KMaxGeneratedfilenamelen =16;
#endif
const TInt KBase64MaxLineLength = 64; // chars
const TInt KFileProtocolStringLength = 7; //file://
const TInt KMinFileNameLen = 4; // eg: c:\<1 digit number> , assuming that the property name was zero len.
// But always the property name will be at least 1 // char in length .
// This constant used in LoadBinaryValuesFromFilesL() to check whether the URI is fine
_LIT8(KValue,"VALUE");
_LIT8(KUri,"URI");
_LIT(KFileProtocol,"file://");
#define UNUSED_VAR(a) a = a
//
// CParserParam
//
EXPORT_C CParserParam* CParserParam::NewL(const TDesC8& aName,const TDesC8& aValue)
/** Allocates and constructs a new property parameter with the name and value specified.
This object does does not take ownership of aName or aValue.
@param aName The parameter name.
@param aValue The parameter value. Use KNullDesC8 if not applicable.
@return Pointer to the newly created property parameter. */
{
HBufC8* paramName=aName.AllocLC();
HBufC8* value=NULL;
if (aValue.Length()>0)
value=aValue.AllocLC();
CParserParam* param=new(ELeave) CParserParam(paramName,value);
if (value)
CleanupStack::Pop(value);
CleanupStack::Pop(paramName);
return param;
}
EXPORT_C CParserParam* CParserParam::NewL(const TDesC8& aName,const TDesC& aValue)
/** Allocates and constructs a new property parameter with the name and value specified.
This object does does not take ownership of aName or aValue.
A Unicode value string is converted to a narrow string for storage.
@param aName The parameter name.
@param aValue The parameter value. (Use KNullDesC if applicable).
@return Pointer to the newly created property parameter. */
{
HBufC8* paramName=aName.AllocLC();
HBufC8* value=NULL;
TInt len=aValue.Length();
if (len>0)
{
value=HBufC8::NewLC(len);
value->Des().Copy(aValue);
}
CParserParam* param=new(ELeave) CParserParam(paramName,value);
if (value)
CleanupStack::Pop(value);
CleanupStack::Pop(paramName);
return param;
}
EXPORT_C CParserParam::~CParserParam()
/** Frees all resources owned by the property parameter, prior to its destruction. */
{
delete iParamName;
delete iValue;
}
EXPORT_C void CParserParam::SetValueL(const TDesC8& aValue)
/** Sets the property parameter value.
@param aValue The new property parameter value. */
{
delete iValue;
iValue=0;
iValue=aValue.AllocL();
}
EXPORT_C void CParserParam::SetValueL(HBufC8* aValue)
/** Sets the property parameter value.
The property parameter takes ownership of aValue.
@param aValue The new property parameter value. */
{
delete iValue;
iValue=aValue;
}
EXPORT_C TInt CParserParam::ExternalizeL(RWriteStream& aStream) const
/** Externalises a property parameter to the stream, in the form NAME=VALUE (or just
NAME, depending on whether there is a value).
This function performs the esacaping of characters.
@param aStream Stream to which the property parameter is to be externalised.
@return The length of data written to the stream. */
{
//
// Write a property parameter in the format of
// NAME=VALUE
//
aStream.WriteL(*iParamName);
TInt outputLen=iParamName->Length();
// If there isn't a VALUE part for this property parameter then just return here...
if (!iValue)
return outputLen;
// Write the equals...
aStream.WriteL(KVersitTokenEquals);
// Escape semi-colon characters
TInt length = iValue->Length();
TInt ii;
TUint8 ch;
outputLen+=length+1; //1 for the "="
for (ii=0;ii<length;++ii)
{
ch=(*iValue)[ii];
if (ch==KVersitTokenSemiColonVal || ch==KVersitTokenBackslashVal)
{
aStream.WriteUint8L(KVersitTokenBackslashVal);
++outputLen;
}
aStream.WriteUint8L(ch);
}
return outputLen;
}
EXPORT_C TInt CParserParam::ExternalizeL(RWriteStream& aStream, TInt& aLengthOutput, CVersitParser* aVersitParser) const
/** Externalises vCard3.0 property parameter to the stream, in the form NAME=VALUE or just
VALUE, if it is a nameless parameter.
This function performs the esacaping of characters. */
{
TBool namelessParam = EFalse;
/** Property parameter contains value only -> TEL;Home:984536577 in which case iParamName
contains the parameter value. */
HBufC8* buf = NULL;
TInt nameLen = 0;
if(iValue == NULL)
{
buf = iParamName;
namelessParam = ETrue;
}
else
{
buf = iValue;
nameLen = iParamName->Length()+1; //1 for the "="
}
//allocate a buffer large enough to cope with all characters in the string being
//escaped. If this allocation fails no escaping is attempted which will result in
//the creation of an invalid vCard
HBufC8* valueBuf = HBufC8::NewLC(2*buf->Length());
TPtr8 valuePtr(valueBuf->Des());
/** Escape semi-colon,backslash,comma characters in parameter value. */
const TUint8* pSource = buf->Ptr();
TInt length = buf->Length();
for(TInt i = 0; i<length; i++, pSource++)
{
switch (*pSource)
{
case KVersitTokenCommaVal:
{
//replace "," with "\,"
valuePtr.Append(KVersitTokenBackslashVal);
valuePtr.Append(*pSource);
}
break;
case KVersitTokenSemiColonVal:
{
//replace ";" with "\;"
valuePtr.Append(KVersitTokenBackslashVal);
valuePtr.Append(*pSource);
}
break;
case KVersitTokenBackslashVal:
{
//replace "\" with "\\"
valuePtr.Append(KVersitTokenBackslashVal);
valuePtr.Append(*pSource);
}
break;
default:
valuePtr.Append(*pSource);
break;
}
}
TInt nameValueLen = nameLen + valueBuf->Length();
HBufC8* nameValue = HBufC8::NewLC(nameValueLen);
TPtr8 pText(nameValue->Des());
if(!namelessParam)
{
//create text in the form NAME=VALUE.
pText.Append(*iParamName);
pText.Append(KVersitTokenEqualsVal);
pText.Append(*valueBuf);
}
else
{
//nameless parameter.
pText.Append(*valueBuf);
}
//fold property parameter.
if(aVersitParser->PlugIn())
{
aVersitParser->PlugIn()->WrapLine(aStream, aLengthOutput, pText);
}
CleanupStack::PopAndDestroy(nameValue);
CleanupStack::PopAndDestroy(valueBuf);
return aLengthOutput;
}
EXPORT_C TPtrC8 CParserParam::Name() const
/** Gets the property parameter name.
If no name has been set, the function returns an empty string.
@return The property parameter name. */
{
if (iParamName)
return iParamName->Des();
return KVersitTokenEmptyNarrow();
}
EXPORT_C TPtrC8 CParserParam::Value() const
/** Gets the property parameter value.
If no value has been set, the function returns an empty descriptor.
@return The property parameter value. */
{
if (iValue)
return iValue->Des();
return KVersitTokenEmptyNarrow();
}
EXPORT_C HBufC* CParserParam::ValueL() const
/** Gets the property parameter value as a Unicode heap descriptor.
If no value has been set, the function returns an empty descriptor.
@return A Unicode version of the property parameter value. */
{
TInt len=0;
if (iValue)
len=iValue->Length();
HBufC* value=HBufC::NewL(len);
if (iValue)
value->Des().Copy(*iValue);
return value;
}
CParserParam::CParserParam(HBufC8* aName,HBufC8* aValue)
: iParamName(aName)
, iValue(aValue)
{}
//
// TVersitDateTime
//
EXPORT_C TVersitDateTime::TVersitDateTime(const TDateTime& aDateTime,TRelativeTime aRelativeTime)
: iDateTime(aDateTime)
,iRelativeTime(aRelativeTime)
/** Constructs the Versit date/time object with a date/time value and a specification
of whether this value is local to the machine which originated the vCard, local
to the machine on which the code is running, or universal time.
@param aDateTime The date/time value.
@param aRelativeTime The time the date/time value represents. */
{
iFlags = EExportNullFlag;
}
//
// CParserPropertyValue
//
EXPORT_C TBool CParserPropertyValue::SupportsInterface(const TUid& /*aInterfaceUid*/) const
/** Tests whether the property value supports the specified interface.
This implementation returns EFalse.
It is implemented by the derived class CParserTimePropertyValue to return ETrue if
aInterfaceUid is KVersitTimePropertyUid.
@param aInterfaceUid Not used.
@return EFalse. */
{
return EFalse;
}
GLDEF_C void DestroyHBufC(TAny* aHBufC)
{
delete *STATIC_CAST(HBufC**, aHBufC);
}
EXPORT_C void CParserPropertyValue::FoldEncodeAndWriteValueToStreamL(RWriteStream& aStream, const CDesCArray* aValueArray
,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const
{
if (!aValueArray)
return;
TInt count=aValueArray->Count();
if (count==0)
return;
TInt bufferLen=64;
HBufC* unicodeValue = HBufC::NewL(bufferLen);
TPtr pUnicode(unicodeValue->Des());
CleanupStack::PushL(TCleanupItem(DestroyHBufC, &unicodeValue));//unicodeValue's address
TPtrC pValue;
TInt extraLengthNeeded;
TInt ii=0;
FOREVER
{
pValue.Set(aValueArray->MdcaPoint(ii));
extraLengthNeeded=2*pValue.Length()+1+pUnicode.Length()-bufferLen;
if (extraLengthNeeded>0)
{
bufferLen+=32*(1+extraLengthNeeded/32);
unicodeValue=unicodeValue->ReAllocL(bufferLen);
pUnicode.Set(unicodeValue->Des());
}
VersitUtils::AddEscapedString(pUnicode,pValue,aEncodingCharset.iCharSetId);
if (++ii==count)
break;
pUnicode.Append(KVersitTokenSemiColonUnicode);
}
if (iPlugIn)
iPlugIn->AddEscaping(unicodeValue);
FoldAndWriteValueToStreamL(aStream,*unicodeValue,aEncodingCharset,aLengthOutput);
CleanupStack::PopAndDestroy(&unicodeValue);
}
EXPORT_C void CParserPropertyValue::FoldEncodeAndWriteValueToStreamL(RWriteStream& aStream, const TDesC& aValue
,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const
{
TInt length = aValue.Length();
if (!length)
return;
HBufC* unicodeValue = HBufC::NewL(2*length);
TPtr pUnicode(unicodeValue->Des());
CleanupStack::PushL(TCleanupItem(DestroyHBufC, &unicodeValue));
VersitUtils::AddEscapedString(pUnicode,aValue,aEncodingCharset.iCharSetId);
if (iPlugIn)
iPlugIn->AddEscaping(unicodeValue);
FoldAndWriteValueToStreamL(aStream,*unicodeValue,aEncodingCharset,aLengthOutput);
CleanupStack::PopAndDestroy(&unicodeValue);
}
EXPORT_C void CParserPropertyValue::FoldAndWriteValueToStreamL(RWriteStream& aStream, const TDesC& aValue
,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const
{
__ASSERT_DEBUG(aEncodingCharset.iEncoding!=Versit::EEightBitEncoding, Panic(EVersitPanicUnexpectedEightBitEncoding));
HBufC8* narrowBuffer = HBufC8::NewLC(3*aValue.Length());
TPtr8 pText(narrowBuffer->Des());
VersitUtils::UncodeToNarrowL(aValue,pText,aEncodingCharset);
CBufFlat* buffer=NULL;
if (aEncodingCharset.iEncoding!=Versit::ENoEncoding)
{
buffer=CBufFlat::NewL(3*pText.Length()/2);
CleanupStack::PushL(buffer);
TUid encodingUid = VersitUtils::ConArcEncodingUid(aEncodingCharset.iEncoding);
EncodeL(buffer,*narrowBuffer,encodingUid);
pText.Set(buffer->Ptr(0));
if (aEncodingCharset.iEncoding==Versit::EBase64Encoding)
{
if (pText.Length()+aLengthOutput>KMaxExternalizedTokenLength)
VersitUtils::WrapLinesL(*buffer, KBase64MaxLineLength);
buffer->InsertL(buffer->Size(), KVersitTokenCRLF);
pText.Set(buffer->Ptr(0));
}
else
{
TInt firstLineLine=pText.Find(KVersitTokenCRLF);
if (firstLineLine+aLengthOutput>KMaxExternalizedTokenLength)
{
aStream.WriteL(KVersitTokenEquals);
aStream.WriteL(KVersitTokenCRLF);
}
}
aStream.WriteL(pText);
aLengthOutput=0; //aLengthOutput should not be used again when encoding is Quoted-Printable
CleanupStack::PopAndDestroy(buffer);
}
else if (!iPlugIn || !iPlugIn->WrapLine(aStream,aLengthOutput,pText))
{
TPtr8 searchString(NULL,0,0);
TInt lineLength=Max(KMaxExternalizedTokenLength-aLengthOutput,0);
TInt lengthLeft=pText.Length();
TInt searchPos;
while (lengthLeft>lineLength)
{
searchPos=lineLength;
while (searchPos>=0 && pText[searchPos]==CVersitParser::ESpace) //Search for last non-space before wrapping length
--searchPos;
if (searchPos>0)
{
searchString.Set(&pText[0],searchPos,searchPos);
searchPos=searchString.LocateReverse(CVersitParser::ESpace); //If there is one search for a space before that
}
else
searchPos=KErrNotFound;
if (searchPos==KErrNotFound) //If can't break before wrapping length find first suitable place after it
{
searchPos=lengthLeft-lineLength;
searchString.Set(&pText[lineLength],searchPos,searchPos);
searchPos=lineLength+searchString.Locate(CVersitParser::ESpace);
if (searchPos<lineLength)
break; //No more spaces
while (searchPos<lengthLeft && pText[searchPos]==CVersitParser::ESpace)
++searchPos;
--searchPos;
}
searchString.Set(&pText[0],searchPos,searchPos);
aStream.WriteL(searchString);
aStream.WriteL(KVersitLineBreak);
aLengthOutput=2;
lengthLeft-=++searchPos;
if (lengthLeft==0)
{
pText.Set(NULL,0,0);
break;
}
pText.Set(&pText[searchPos],lengthLeft,lengthLeft);
lineLength=KMaxExternalizedTokenLength;
}
aLengthOutput+=pText.Length();
aStream.WriteL(pText);
}
CleanupStack::PopAndDestroy(narrowBuffer);
}
EXPORT_C CParserPropertyValue::CParserPropertyValue(const TUid& aPropertyValueUid)
: iPropertyValueTypeUid(aPropertyValueUid)
{}
EXPORT_C TBool CParserPropertyValue::IsAsciiCharacterSetSufficient()
/** Tests whether the Ascii character set is sufficient to represent a property
value.
This implementation returns ETrue.
It is overridden by classes CParserPropertyValueAlarm, CParserPropertyValueHBufC
and CParserPropertyValueCDesCArray.
This function is called by CParserProperty::ExternalizeL().
@return ETrue. */
{
return ETrue;
}
EXPORT_C void CParserPropertyValue::EncodeL(CBufBase* aTarget,const TDesC8& aSource,const TUid& aEncoding) const
/** Encodes the text property value referred to in aSource, if encoding is required.
Uses the encoding format identified by aEncoding. This is only used for
text property values (e.g. HBufC or DesCArray property types).
Invoked by implementations of ExternalizeL().
@param aTarget A pointer to the buffer which will have the converted text
written into it.
@param aSource The source text.
@param aEncoding An encoding UID. The possible encoding formats are defined
in vuid.h. Specify NULL UID if no encoding is required. */
{
__ASSERT_DEBUG(aTarget, User::Invariant());
RDesReadStream readStream(aSource);
CleanupClosePushL(readStream);
VersitUtils::ConArcEncodeL(readStream, *aTarget, aEncoding);
CleanupStack::PopAndDestroy();
}
EXPORT_C void CParserPropertyValue::Append(TDes16& aTarget,TDesC8& aSource)
{
TInt lenT=aTarget.Length();
TInt lenS=aSource.Length();
aTarget.SetLength(lenT+lenS);
TPtr16 target(&aTarget[lenT],lenS,lenS);
target.Copy(aSource);
}
//
// CParserTimeProperty
//
EXPORT_C CParserTimePropertyValue::CParserTimePropertyValue(const TUid& aPropertyValueUid)
: CParserPropertyValue(aPropertyValueUid)
{}
EXPORT_C TBool CParserTimePropertyValue::SupportsInterface(const TUid& aInterfaceUid) const
/** Tests whether the property value supports the specified interface.
It overrides the base class function, which always returns EFalse.
This function is used to test whether or not a property value is
time-related (i.e. derived from CParserTimePropertyValue). It returns
ETrue if aInterfaceUid is KVersitTimePropertyUid.
@param aInterfaceUid An interface UID.
@return ETrue if KVersitTimePropertyUid is specified as the interface UID,
otherwise EFalse. */
{
if (aInterfaceUid==TUid::Uid(KVersitTimePropertyUid))
return ETrue;
return CParserPropertyValue::SupportsInterface(aInterfaceUid);
}
EXPORT_C void CParserTimePropertyValue::ConvertDateTime(TDateTime* aDateTime,const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
{
ConvertDateTime(*aDateTime,aIncrement,aDaylight,ETrue);
}
void CParserTimePropertyValue::ConvertDateTime(TDateTime& aDateTime,const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight,TBool aToUTC)
{
TTime runTime(aDateTime);
TBool summerTime=EFalse;
if ((aDaylight)&&(aDaylight->iSavings)&&(aDaylight->iStartTime)&&(aDaylight->iEndTime))
{
TTime savingsStart(aDaylight->iStartTime->iDateTime);
TTime savingsEnd(aDaylight->iEndTime->iDateTime);
if ((runTime>savingsStart)&&(runTime<savingsEnd))
{
if (aToUTC)
runTime-=aDaylight->iOffset;
else
runTime+=aDaylight->iOffset;
summerTime=ETrue;
}
}
if (!summerTime)
runTime+=aIncrement;
aDateTime=runTime.DateTime();
}
EXPORT_C void CParserTimePropertyValue::EncodeVersitDateTimeL(TDes8& aBuf,const TVersitDateTime& aDateTime,TBool aEncodeTime) const
// Convert aDateTime to descriptor format
{
_LIT8(formatString1, "%04d%02d%02d");
aBuf.Format(formatString1, aDateTime.iDateTime.Year(), aDateTime.iDateTime.Month() + 1, aDateTime.iDateTime.Day() + 1);
if (aEncodeTime)
{
_LIT8(formatString2, "%S%02d%02d%02d");
aBuf.AppendFormat(formatString2, &KVersitTimePeriodTime, aDateTime.iDateTime.Hour(), aDateTime.iDateTime.Minute(), aDateTime.iDateTime.Second());
if (aDateTime.iRelativeTime == TVersitDateTime::EIsUTC)
{
aBuf.Append(KVersitTokenUniversalTime);
}
}
}
EXPORT_C void CParserTimePropertyValue::EncodeTimePeriodL(TDes8& aBuf,const TTime& aTimePeriod) const
{
_LIT8(formatString, "%d%S");
TDateTime dateTime = aTimePeriod.DateTime();
aBuf=KVersitTimePeriodBegin;
TInt time = dateTime.Year();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodYear);
time = dateTime.Month();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodMonth);
time = dateTime.Day();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodDay);
aBuf.Append(KVersitTimePeriodTime);
time = dateTime.Hour();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodHour);
time = dateTime.Minute();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodMinute);
time = dateTime.Second();
if (time)
aBuf.AppendFormat(formatString, time, &KVersitTimePeriodSecond);
}
//
// CParserPropertyValueHBufC
//
EXPORT_C CParserPropertyValueHBufC::CParserPropertyValueHBufC(HBufC16* aValue)
:CParserPropertyValue(TUid::Uid(KVersitPropertyHBufCUid)),iValue(aValue)
{}
CParserPropertyValueHBufC::CParserPropertyValueHBufC()
: CParserPropertyValue(TUid::Uid(KVersitPropertyHBufCUid))
{
}
void CParserPropertyValueHBufC::ConstructL(const TDesC& aValue)
{
iValue = aValue.AllocL();
}
EXPORT_C CParserPropertyValueHBufC* CParserPropertyValueHBufC::NewL(const TDesC& aValue)
/** Allocates and constructs a new heap descriptor property value with a descriptor.
Sets the property value's UID to KVersitPropertyHBufCUid.
@param aValue The property value.
@return Pointer to the newly created heap descriptor property value. */
{
CParserPropertyValueHBufC* self = new(ELeave) CParserPropertyValueHBufC();
CleanupStack::PushL(self);
self->ConstructL(aValue);
CleanupStack::Pop(self);
return self;
}
EXPORT_C CParserPropertyValueHBufC::~CParserPropertyValueHBufC()
/** Frees all resources owned by the property value, prior to its destruction. */
{
delete iValue;
}
EXPORT_C TBool CParserPropertyValueHBufC::IsAsciiCharacterSetSufficient()
// From CParserPropertyValue
/** Tests whether the property value can be represented using the ASCII character
set.
@return ETrue if the property value can be represented using the ASCII character
set. If not, EFalse. */
{
return VersitUtils::DescriptorContainsOnlySevenBitCharacters(*iValue);
}
EXPORT_C void CParserPropertyValueHBufC::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
/** Externalizes the descriptor property value into aStream.
This function is invoked by the parser's ExternalizeL() function.
@param aStream Stream into which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
@param aLengthOutput The amount of text that has been output so far on the
line, which needs to be taken into account when calculating if and where any
line break should occur. */
{
FoldEncodeAndWriteValueToStreamL(aStream,Value(),aEncodingCharset,aLengthOutput);
}
EXPORT_C TPtrC CParserPropertyValueHBufC::Value() const
/** Retrieves the property value.
@return Pointer descriptor representing the property value. */
{
if (iValue)
return iValue->Des();
return KVersitTokenEmpty();
}
EXPORT_C HBufC* CParserPropertyValueHBufC::TakeValueOwnership()
/** Take ownership of the heap descriptor property value.
The property value previously owned by the object is deleted.
@return A pointer to the property value. */
{
HBufC* value=iValue;
iValue=NULL;
return value;
}
EXPORT_C CParserPropertyValueCDesCArray* CParserPropertyValueHBufC::TreatAsArrayPropertyLC(const CParserProperty& aOwningProperty) const
/** Treats this HBufC-based property value as a possible array-based property.
This function was added for compatibility reasons to support array-based SOUND
property values. This does not alter the representation of this parser property
value.
If the underlying HBufC value cannot be parsed into any array elements, then this method
returns an array containing only a single item. Otherwise, the HBufC is split into its
constituent elements and returned as an array.
@param aOwningProperty The property that contains this property value.
@return An array-based representation of this object. */
{
CDesCArray* arrayOfValues = NULL;
const CParserPropertyValue* valueFromStorage = VersitUtils::AdditionalPropertyValueFromStorageL(aOwningProperty);
//
if (valueFromStorage && valueFromStorage->Uid().iUid == KVersitPropertyCDesCArrayUid)
{
const CParserPropertyValueCDesCArray* valueAsArrayProperty = static_cast<const CParserPropertyValueCDesCArray*>(valueFromStorage);
CDesCArray* array = valueAsArrayProperty->Value();
//
if (array && array->Count())
{
// Create a new array...
const TInt count = array->Count();
arrayOfValues = new(ELeave) CDesCArrayFlat(count);
CleanupStack::PushL(arrayOfValues);
// ... and copy the elements
for(TInt i=0; i<count; i++)
{
arrayOfValues->AppendL(array->MdcaPoint(i));
}
}
}
if (!arrayOfValues)
{
// Just copy the single element in the HBufC structure to the
// first element of an array-based structure.
arrayOfValues = new(ELeave) CDesCArrayFlat(1);
CleanupStack::PushL(arrayOfValues);
arrayOfValues->AppendL(Value());
}
// Create array-property storage type...
CParserPropertyValueCDesCArray* value = new(ELeave) CParserPropertyValueCDesCArray(arrayOfValues);
CleanupStack::Pop(arrayOfValues);
CleanupStack::PushL(value);
//
return value;
}
//
// CParserPropertyValueBinary
//
void CParserPropertyValueBinary::ConstructL(const TDesC8& aValue)
{
iValue=CBufSeg::NewL(128);
iValue->InsertL(0,aValue);
}
EXPORT_C CParserPropertyValueBinary* CParserPropertyValueBinary::NewL(const TDesC8& aValue)
/** Allocates and constructs a new binary property value with the value specified.
Sets the property value's UID to KVersitPropertyBinaryUid.
@param aValue The property value.
@return Pointer to the newly created binary property value. */
{
CParserPropertyValueBinary* self = CParserPropertyValueBinary::NewLC(aValue);
CleanupStack::Pop(self);
return self;
}
EXPORT_C CParserPropertyValueBinary* CParserPropertyValueBinary::NewLC(const TDesC8& aValue)
/** Allocates and constructs a new binary property value with the value specified.
Leaves the object on the cleanup stack.
Sets the property value's UID to KVersitPropertyBinaryUid.
@param aValue The property value.
@return Pointer to the newly created binary property value. */
{
CParserPropertyValueBinary* self = new(ELeave) CParserPropertyValueBinary();
CleanupStack::PushL(self);
self->ConstructL(aValue);
return self;
}
EXPORT_C CParserPropertyValueBinary::~CParserPropertyValueBinary()
/** Frees all resources owned by the property value, prior to its destruction. */
{
delete iValue;
}
EXPORT_C void CParserPropertyValueBinary::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& aEncodingCharset, TInt aLengthOutput)
/** Externalises the binary property value into aStream.
Uses the encoding format specified in aEncodingCharset. (Any character set
specified in aEncodingCharset is not used).
@param aStream Stream into which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
The encoding selected for a binary property value is Versit::EBase64Encoding.
@param aLengthOutput The amount of text that has been output so far on the
line (for the property name). */
{
RBufReadStream readStream;
readStream.Open(*iValue);
CleanupClosePushL(readStream);
ExternalizeL(aStream, aEncodingCharset, aLengthOutput, readStream);
CleanupStack::PopAndDestroy(&readStream);
}
void CParserPropertyValueBinary::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& aEncodingCharset, TInt aLengthOutput, RReadStream& aReadStream)
/** Externalises the binary property value into aStream.
Uses the encoding format specified in aEncodingCharset. (Any character set
specified in aEncodingCharset is not used).
@param aStream Stream into which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
The encoding selected for a binary property value is Versit::EBase64Encoding.
@param aLengthOutput The amount of text that has been output so far on the
line (for the property name). */
{
TAny* extPlugIn = NULL;
if (PlugIn())
{
PlugIn()->GetInterface(KUidVersitPlugInExtension, extPlugIn);
}
TInt dataLength = 0;
MStreamBuf * streamBuf = aReadStream.Source();
if(streamBuf)
{
dataLength = streamBuf->SizeL();
}
if (dataLength > 0)
{
//Make sure read from the beginning
TStreamPos posStart(0);
streamBuf->SeekL(MStreamBuf::ERead, posStart);
/*
1). Create a segmented buffer with optimum granularity, this will have the converted data.
2). Read chunk of data from aReadStream and store it in temporary segmented buffer for processing.
3). Pass the buffer for line wrapping and write it to the output stream.
4). Repeat the steps in the loop until data in iValue is exhausted.
*/
//Number of segments to process.
TInt splitSize = 30720; //optimum size of buffer which CONARC
CBufSeg* target = CBufSeg::NewL(splitSize);
CleanupStack::PushL(target);
CBufSeg* tempSeg = CBufSeg::NewL(splitSize);
CleanupStack::PushL(tempSeg);
HBufC8* readdata = HBufC8::NewLC(splitSize);
RBufReadStream readStream;
TPtr8 ptr = readdata->Des();
TInt numOfSplits = dataLength / splitSize;
for(TInt loop = 0;loop <= numOfSplits; ++loop)
{
if(loop == numOfSplits)
{//The length of data to read at the last loop
splitSize = dataLength%splitSize;
if(splitSize == 0)
{
break;
}
}
ptr.Zero();
aReadStream.ReadL(ptr, splitSize);
tempSeg->InsertL(0, ptr);
readStream.Open(*tempSeg);
CleanupClosePushL(readStream);
// Do the BASE64 encoding
VersitUtils::ConArcEncodeL(readStream, *target, VersitUtils::ConArcEncodingUid(aEncodingCharset.iEncoding));
CleanupStack::PopAndDestroy(&readStream);
if (!extPlugIn || !static_cast<MVersitPlugInExtension*>(extPlugIn)->WrapBinaryLinesL(*target, aLengthOutput))
{
VersitUtils::WrapLinesL(*target, KBase64MaxLineLength);
}
// Write the buffer to the output stream
TInt bufPos = 0;
TInt len = target->Size();
while (bufPos < len)
{
TPtr8 ptr = target->Ptr(bufPos);
aStream.WriteL(ptr);
bufPos += ptr.Length();
}
tempSeg->Reset();
ptr.Zero();
target->Reset();
}
CleanupStack::PopAndDestroy(3, target);//readdata tempSeg target
}
// vCard specification says that end of the text is marked with two CRLF sequences (2nd one added latter)
if (!extPlugIn || !static_cast<MVersitPlugInExtension*>(extPlugIn)->DisableBlankLineAfterBinaryValue())
{
aStream.WriteL(KVersitTokenCRLF);
}
}
EXPORT_C const CBufSeg* CParserPropertyValueBinary::Value() const
/** Returns the binary property value.
@return Pointer to the property value. */
{
return iValue;
}
//
// CParserPropertyValueBinaryFile
//
void CParserPropertyValueBinaryFile::ConstructL(const RFile& aFileHandle)
{
RFile dupHandle;
User::LeaveIfError(dupHandle.Duplicate(aFileHandle));
iFileStream.Attach(dupHandle);
}
EXPORT_C CParserPropertyValueBinaryFile* CParserPropertyValueBinaryFile::NewL(const RFile& aFileHandle)
/** Allocates and constructs a new file property value with the file handle to the data.
The property value's UID will be set to KVersitPropertyBinaryUid.
@param aFileHandle The file handle to the binary data.
@return Pointer to the newly created file property value. */
{
CParserPropertyValueBinaryFile* self = new(ELeave) CParserPropertyValueBinaryFile();
CleanupStack::PushL(self);
self->ConstructL(aFileHandle);
CleanupStack::Pop(self);
return self;
}
EXPORT_C CParserPropertyValueBinaryFile::~CParserPropertyValueBinaryFile()
/** Frees all resources owned by the property value, prior to its destruction. */
{
iFileStream.Close();
}
void CParserPropertyValueBinaryFile::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& aEncodingCharset, TInt aLengthOutput)
/** Externalises the binary data through the file handle into aStream.
Uses the encoding format specified in aEncodingCharset. (Any character set
specified in aEncodingCharset is not used).
@param aStream Stream into which the value is to be externalized.
@param aEncodingCharset Specifies the character set and encoding information.
The encoding selected for a binary property value is Versit::EBase64Encoding.
@param aLengthOutput The amount of text that has been output so far on the
line (for the property name). */
{
CParserPropertyValueBinary::ExternalizeL(aStream, aEncodingCharset, aLengthOutput, iFileStream);
}
//
// CParserPropertyValueCDesCArray
//
EXPORT_C CParserPropertyValueCDesCArray::CParserPropertyValueCDesCArray(CDesCArray* aValue)
: CParserPropertyValue(TUid::Uid(KVersitPropertyCDesCArrayUid))
,iValue(aValue)
/** Constructs a new descriptor array property value with the array pointed to
by aValue.
Sets the property value's UID to KVersitPropertyCDesCArrayUid.
The property value takes ownership of aValue.
Called by CVersitParser::MakePropertyValueL() when internalising from a
stream.
@param aValue Pointer to the descriptor array. */
{}
EXPORT_C CParserPropertyValueCDesCArray::~CParserPropertyValueCDesCArray()
/** Frees all resources owned by the property value array, prior to its destruction. */
{
delete iValue;
}
EXPORT_C TBool CParserPropertyValueCDesCArray::IsAsciiCharacterSetSufficient()
// From CParserPropertyValue
/** Tests whether the property value can be represented using the ASCII character
set.
Tests every item in the array and returns ETrue only if all items contain only
7-bit characters.
@return ETrue if the property value can be represented using the ASCII character
set. If not, EFalse.
@see VersitUtils::DescriptorContainsOnlySevenBitCharacters() */
{
if (!iValue)
return ETrue;
TInt count = iValue->Count();
if (!count)
return ETrue;
for(TInt i=0; i<count; i++)
{
const TDesC& item = (*iValue)[i];
if (!VersitUtils::DescriptorContainsOnlySevenBitCharacters(item))
return EFalse;
}
return ETrue;
}
EXPORT_C void CParserPropertyValueCDesCArray::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
// From CParserPropertyValue
/** Externalizes the descriptor array property value into aStream.
Uses the character set and encoding format specified in aEncodingCharset.
Called by CParserProperty::ExternalizeL().
@param aStream Stream into which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
@param aLengthOutput The amount of text that has been output so far on the
line (for the property name), which needs to be taken into account when calculating
if and where any line break should occur. */
{
FoldEncodeAndWriteValueToStreamL(aStream, iValue, aEncodingCharset, aLengthOutput);
}
EXPORT_C TBool CParserPropertyValueCDesCArray::IsPresent(const TDesC& aValue) const
/** Tests whether a specified value is present in the array of descriptors owned
by the property value object.
Not used internally.
@param aValue The value of interest.
@return ETrue if the value specified is present in the descriptor array. EFalse
if not. */
{
if (iValue)
{
TInt count=iValue->Count();
for (TInt ii=0; ii<count; ii++)
{
if ((*iValue)[ii]==aValue)
{
return ETrue;
}
}
}
return EFalse;
}
//
// CParserPropertyValueTimeZone
//
EXPORT_C CParserPropertyValueTimeZone::CParserPropertyValueTimeZone(TTimeIntervalSeconds aValue)
: CParserPropertyValue(TUid::Uid(KVersitPropertyTimeZoneUid))
, iValue(aValue)
/** Constructs a new time zone property value parser with a time interval in seconds,
which represents the universal time offset of the time zone.
Sets the property value's UID to KVersitPropertyTimeZoneUid.
@param aValue A time interval (in seconds) which represents the offset of
the time zone from universal time. The property value takes ownership of the
pointer. */
{}
void CParserPropertyValueTimeZone::EncodeTimeZone(TDes8& aBuf,TTimeIntervalSeconds aValue)
{
TInt hours=aValue.Int()/3600;
TInt sign=1;
_LIT8(KTwoDigits,"%02d");
if (hours<0) //This code could be simplified if & when the E32 bug is fixed.
{
_LIT8(KMinus,"-");
aBuf=KMinus;
sign=-1;
}
else
{
_LIT8(KPlus,"+");
aBuf=KPlus;
}
aBuf.AppendFormat(KTwoDigits,sign*hours);
TInt minutes=sign*(aValue.Int()/60-60*hours);
if (minutes>0)
aBuf.AppendFormat(KTwoDigits,minutes);
}
EXPORT_C void CParserPropertyValueTimeZone::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/
,TInt /*aLengthOutput*/)
/** Externalises the time zone property value into aStream.
@param aStream Stream into which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
(Not used by this function).
@param aLengthOutput The amount of text that has been output so far
on the line. (Not used by this function). */
{
TBuf8<KVersitDefaultBufferSize> buf;
EncodeTimeZone(buf,iValue.Int());
aStream.WriteL(buf);
}
//
// CVersitDaylight
//
CVersitDaylight::CVersitDaylight(TBool aSavings, TTimeIntervalSeconds aOffset, TVersitDateTime* aStartTime, TVersitDateTime* aEndTime)
: iSavings(aSavings),
iOffset(aOffset),
iStartTime(aStartTime),
iEndTime(aEndTime)
{
if (aSavings)
{
iStartTimeSortKey = TTime(iStartTime->iDateTime).Int64();
}
else
{
iStartTimeSortKey = TTime(Time::MinTTime()).Int64();
}
}
void CVersitDaylight::ConstructL(const TDesC& aStandardDesignation, const TDesC& aDaylightDesignation)
{
iStandardDesignation = aStandardDesignation.AllocL();
CleanupStack::PushL(iStandardDesignation);
iDaylightDesignation = aDaylightDesignation.AllocL();
CleanupStack::Pop(iStandardDesignation);
}
EXPORT_C CVersitDaylight* CVersitDaylight::NewL(TBool aSavings, TTimeIntervalSeconds aOffset, TVersitDateTime* aStartTime, TVersitDateTime* aEndTime, const TDesC& aStandardDesignation, const TDesC& aDaylightDesignation)
/** Allocates and constructs a new universal time offset object.
Ownership of aStartTime and aEndTime is taken at end of this function.
@param aSavings The daylight savings flag, i.e. ETrue if daylight saving is
currently observed in the locale; EFalse if not.
@param aOffset The universal time offset (in seconds).
@param aStartTime The date/time at which the period for daylight saving begins.
@param aEndTime The date/time at which the period for daylight saving ends.
@param aStandardDesignation The standard time designation, e.g. GMT, EST.
@param aDaylightDesignation The daylight saving time designation, e.g. BST,
EDT.
@return The new universal time offset object. */
{
CVersitDaylight* self = new(ELeave) CVersitDaylight(aSavings, aOffset, aStartTime, aEndTime);
CleanupStack::PushL(STATIC_CAST(TAny*,self));
self->ConstructL(aStandardDesignation, aDaylightDesignation);
CleanupStack::Pop(self);
return self;
}
EXPORT_C CVersitDaylight::~CVersitDaylight()
/** The destructor frees all resources owned by the object, prior to its destruction. */
{
delete iStartTime;
delete iEndTime;
delete iStandardDesignation;
delete iDaylightDesignation;
}
//
// CParserPropertyValueDaylight
//
EXPORT_C CParserPropertyValueDaylight::CParserPropertyValueDaylight(CVersitDaylight* aValue)
: CParserTimePropertyValue(TUid::Uid(KVersitPropertyDaylightUid)), iValue(aValue)
/** Constructs a new CParserPropertyValueDaylight.
Sets the property value's UID to KVersitPropertyDaylightUid.
@param aValue Pointer to the daylight saving specification. The property value
takes ownership of the pointer. */
{}
EXPORT_C CParserPropertyValueDaylight::~CParserPropertyValueDaylight()
/** Frees all resources owned by the property value, prior to its destruction. */
{
delete iValue;
}
EXPORT_C void CParserPropertyValueDaylight::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& /*aIncrement*/,const CVersitDaylight* /*aDaylight*/)
/** This function does nothing, as daylight saving times should always be specified
as local times.
@param aIncrement Not used.
@param aDaylight Not used.
@deprecated since 9.1
*/
{}
EXPORT_C void CParserPropertyValueDaylight::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& /*aIncrement*/)
/** Converts the start and end times for the daylight saving period to machine-local.
This process involves adjusting the date/time values by the offset in aIncrement.
It has no effect if daylight savings is not in effect or on values
already stored in machine-local time.
This function is deprecated.
@param aIncrement A time interval in seconds to add to the start and end date/times
for daylight saving. This should normally be the universal time offset for
the machine's locale.
@deprecated since 9.1
*/
{
}
EXPORT_C void CParserPropertyValueDaylight::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& aEncodingCharset,TInt aLengthOutput)
// From CParserProperty
/** Externalizes the daylight saving property value into aStream.
This is invoked by the parser's ExternalizeL() function.
@param aStream Stream to which the value is to be externalised.
@param aEncodingCharset Specifies the character set and encoding information.
@param aLengthOutput The amount of text that has been output so far on the
line, which needs to be taken into account when calculating if and where any
line break should occur. */
{
if (!iValue)
return;
TBuf<64> buf;
if (!iValue->iSavings)
buf.Append(KVersitVarTokenFALSE);
else
{
buf.Append(KVersitVarTokenTRUE);
buf.Append(KVersitTokenSemiColonUnicode);
TBuf8<KVersitDefaultBufferSize> timeBuf;
CParserPropertyValueTimeZone::EncodeTimeZone(timeBuf,iValue->iOffset);
Append(buf,timeBuf);
buf.Append(KVersitTokenSemiColonUnicode);
if (iValue->iStartTime)
{
EncodeVersitDateTimeL(timeBuf,*iValue->iStartTime);
Append(buf,timeBuf);
}
buf.Append(KVersitTokenSemiColonUnicode);
if (iValue->iEndTime)
{
EncodeVersitDateTimeL(timeBuf,*iValue->iEndTime);
Append(buf,timeBuf);
}
buf.Append(KVersitTokenSemiColonUnicode);
if (iValue->iStandardDesignation)
{
buf.Append(*(iValue->iStandardDesignation));
}
buf.Append(KVersitTokenSemiColonUnicode);
if (iValue->iDaylightDesignation)
{
buf.Append(*(iValue->iDaylightDesignation));
}
}
FoldAndWriteValueToStreamL(aStream,buf,aEncodingCharset,aLengthOutput);
}
//
// CParserPropertyValueDateTimeL
//
EXPORT_C CParserPropertyValueDateTime::CParserPropertyValueDateTime(TVersitDateTime* aValue)
: CParserTimePropertyValue(TUid::Uid(KVersitPropertyDateTimeUid))
, iValue(aValue)
/** Constructs a CParserPropertyValueDateTime with a TVersitDateTime value.
Sets the property value's UID to KVersitPropertyDateTimeUid.
@param aValue Pointer to the date/time specification, which includes information
about the date/time. The property value takes ownership of the pointer. */
{}
EXPORT_C CParserPropertyValueDateTime::~CParserPropertyValueDateTime()
/** Frees all resources owned by the property value, prior to its destruction. */
{
delete iValue;
}
EXPORT_C void CParserPropertyValueDateTime::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
/** Converts the object's date/time value into universal time.
The date/time is checked against the daylight saving information provided
in aDaylight. If it falls inside the daylight saving period then the daylight
saving offset is subtracted from the time to convert it to universal time.
Otherwise aIncrement is added to the date/time to convert it to universal
time.
Note that the daylight savings offset will adjust the time both for the daylight
saving and for the time zone.
The function has no effect if the value is already stored as universal time.
If aDaylight is a NULL pointer then aIncrement is used.
@param aIncrement A time interval in seconds which represents the negative
of the time zone of the originating machine.For instance, if the time zone
is +04:30 (that is 4hr 30mins ahead of UTC), aIncrement should be set to minus
the number of seconds in 4hr 30mins.
@param aDaylight Pointer to the specification for daylight saving. If the date/time
value is within the period for daylight saving, the value is modified by the
daylight saving offset (which accounts for both the time zone and daylight
saving rule).
@deprecated since 9.1
*/
{
if ((iValue) && (iValue->iRelativeTime!=TVersitDateTime::EIsUTC) && !iValue->IsFlagSet(TVersitDateTime::EExportLeaveAsLocalTime))
{
ConvertDateTime(&iValue->iDateTime,aIncrement,aDaylight);
iValue->iRelativeTime=TVersitDateTime::EIsUTC;
}
}
EXPORT_C void CParserPropertyValueDateTime::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement)
/** Converts the date/time property value into machine-local time.
This process involves adjusting the date/time value by the offset in aIncrement.
The function has no effect if the value is already stored as machine-local
time.
@param aIncrement A time interval which represents the number of seconds which
is to be added to the date/time value. This should normally be the universal
time offset for the machine's locale.
@deprecated since 9.1
*/
{
if ((iValue)&&(iValue->iRelativeTime==TVersitDateTime::EIsUTC))
{
ConvertDateTime(&iValue->iDateTime,aIncrement,NULL);
iValue->iRelativeTime=TVersitDateTime::EIsMachineLocal;
}
}
EXPORT_C void CParserPropertyValueDateTime::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/
,TInt /*aLengthOutput*/)
// From CParserPropertyValue
/** Externalises the date/time property value to aStream.
@param aStream Stream to which the value should be externalised
@param aEncodingCharset Specifies the character set and encoding information. This
is not used by this function.
@param aLengthOutput The amount of text that has been output so far on the line (for the
property name). This is not used by this function. */
{
if (iValue)
{
TBuf8<KVersitMaxDateTimeLength> buf;
EncodeVersitDateTimeL(buf,*iValue);
aStream.WriteL(buf);
}
}
//
// CParserPropertyValueDate
//
EXPORT_C CParserPropertyValueDate::CParserPropertyValueDate(TVersitDateTime* aValue)
:CParserTimePropertyValue(TUid::Uid(KVersitPropertyDateUid))
,iValue(aValue)
/** Constructs a date property value parser with a TVersitDateTime value.
Sets the property value's UID to KVersitPropertyDateUid.
@param aValue Specifies the date and information about the date. The object
takes ownership of the pointer. */
{}
EXPORT_C CParserPropertyValueDate::~CParserPropertyValueDate()
/** Frees all resources owned by the object, prior to its destruction. */
{
delete iValue;
}
EXPORT_C void CParserPropertyValueDate::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& /*aIncrement*/,const CVersitDaylight* /*aDaylight*/)
/** This function is inherited from the base class CParserTimePropertyValue.
It has an empty implementation because this class represents a date not a time value.
@param aIncrement Not used.
@param aDaylight Not used.
@deprecated since 9.1
*/
{}
EXPORT_C void CParserPropertyValueDate::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& /*aIncrement*/)
/** This function is inherited from the base class CParserTimePropertyValue.
It has an empty implementation because this class represents a date not a time value.
@param aIncrement Not used.
@deprecated since 9.1
*/
{}
EXPORT_C void CParserPropertyValueDate::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/,TInt /*aLengthOutput*/)
// From CParserProperty
/** Externalises the property value into aStream.
@param aStream Stream to which the value should be externalised.
@param aEncodingCharset Specifies the character set and encoding information. This
information is not used by this function
@param aLengthOutput The amount of text that has been output so far on the line
(for the property name). This value is not used by this function. */
{
if (iValue)
{
TBuf8<KVersitMaxDateTimeLength> buf;
EncodeVersitDateTimeL(buf,*iValue,EFalse);
aStream.WriteL(buf);
}
}
//
// CParserPropertyValueMultiDateTimeL
//
EXPORT_C CParserPropertyValueMultiDateTime::CParserPropertyValueMultiDateTime(CArrayPtr<TVersitDateTime>* aValue)
: CParserTimePropertyValue(TUid::Uid(KVersitPropertyMultiDateTimeUid))
,iValue(aValue)
/** Constructs a multi-date/time property value parser with an array of TVersitDateTimes.
Sets the property value's UID to KVersitPropertyMultiDateTimeUid.
@param aValue Pointer to an array of TVersitDateTime objects, each of which
specifies a date/time value, and information about the value. The property
value takes ownership of the array. */
{}
EXPORT_C CParserPropertyValueMultiDateTime::~CParserPropertyValueMultiDateTime()
/** Frees all resources owned by the property value, prior to its destruction. */
{
if (iValue)
{
iValue->ResetAndDestroy();
delete iValue;
}
}
EXPORT_C void CParserPropertyValueMultiDateTime::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
/** Converts each of the date/time values owned by the object into universal time.
Each date/time is checked against the daylight saving information provided
in aDaylight. If it falls inside the daylight saving period then the daylight
saving offset is subtracted from the time to convert it to universal time.
Otherwise aIncrement is added to the date/time of the alarm to convert it
to universal time.
Note that the daylight savings offset will adjust the time both for the daylight
saving and for the time zone.
The function does not effect any date/time value already stored in universal
time.
If aDaylight is a NULL pointer then aIncrement is used.
@param aIncrement A time interval in seconds which represents the negative
of the time zone of the originating machine. For instance, if the time zone
is +04:30 (that is 4hr 30mins ahead of UTC), aIncrement should be set to minus
the number of seconds in 4hr 30mins.
@param aDaylight Pointer to the specification for daylight saving. If the time
value is within the period for daylight saving, the value is modified by the
daylight saving offset (which accounts for both the time zone and daylight
saving rule).
@deprecated since 9.1
*/
{
if (iValue)
{
TInt count=iValue->Count();
for (TInt ii=0;ii<count; ii++)
{
TVersitDateTime& time=*(*iValue)[ii];
if (!(time.iRelativeTime==TVersitDateTime::EIsUTC) && !time.IsFlagSet(TVersitDateTime::EExportLeaveAsLocalTime))
{
ConvertDateTime(&time.iDateTime,aIncrement,aDaylight);
time.iRelativeTime=TVersitDateTime::EIsUTC;
}
}
}
}
EXPORT_C void CParserPropertyValueMultiDateTime::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement)
/** Converts the date/time property values into machine-local time.
This process involves adjusting the date/time values by the offset in aIncrement.
The function has no effect on any values already stored in machine-local time.
@param aIncrement A time interval which represents the number of seconds which
is to be added to the date/time values. This should normally be the universal
time offset for the machine's locale.
@deprecated since 9.1
*/
{
if (iValue)
{
TInt count=iValue->Count();
for (TInt ii=0;ii<count; ii++)
{
if ((*iValue)[ii]->iRelativeTime==TVersitDateTime::EIsUTC)
{
ConvertDateTime(&(*iValue)[ii]->iDateTime,aIncrement,NULL);
(*iValue)[ii]->iRelativeTime=TVersitDateTime::EIsMachineLocal;
}
}
}
}
EXPORT_C void CParserPropertyValueMultiDateTime::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/
,TInt aLengthOutput)
// From CParserPropertyValue
/** Externalises the array of date/time property values into aStream.
@param Stream to which the value should be externalised.
@param Specifies the character set and encoding information. This information
is not used by this function.
@param The amount of text that has been output on the line so far, which
needs to be taken into account when calculating if and where any line break
should occur. */
{
const TInt maxCharsTimeOutput=KVersitMaxDateTimeLength+1;
if (iValue)
{
TBuf8<KVersitMaxDateTimeLength> buf;
TInt count = iValue->Count();
TInt ii=0;
FOREVER
{
if (aLengthOutput+maxCharsTimeOutput>KMaxExternalizedTokenLength)
{
aStream.WriteL(KVersitLineBreak);
aLengthOutput=2;
}
EncodeVersitDateTimeL(buf,*(*iValue)[ii]);
aStream.WriteL(buf);
if (++ii==count)
break;
aStream.WriteL(KVersitTokenSemiColon);
aLengthOutput+=buf.Length()+1;
}
}
}
//
// CParserPropertyValueInt
//
EXPORT_C CParserPropertyValueInt::CParserPropertyValueInt(TInt aValue)
: CParserPropertyValue(TUid::Uid(KVersitPropertyIntUid)), iValue(aValue)
/** Constructs the property value with a signed integer.
Sets the property value's UID to KVersitPropertyIntUid.
@param aValue A signed integer value. */
{}
EXPORT_C void CParserPropertyValueInt::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/,TInt /*aLengthOutput*/)
// From CParserPropertyValue
/** Externalizes the integer property value to aStream.
@param aStream Stream to which the value is to be externalised
@param aEncodingCharset Specifies the character set and encoding information.
Not used by this function.
@param aLengthOutput The amount of text that has been output so far on the line.
Not used by this function.*/
{
TBuf8<KVersitDefaultBufferSize> buf;
buf.Num(iValue);
aStream.WriteL(buf);
}
//
// CParserProperty
//
EXPORT_C CParserProperty::CParserProperty(CParserPropertyValue& aPropertyValue,CArrayPtr<CParserParam>* aArrayOfParams)
: iPropertyValue(&aPropertyValue), iArrayOfParams(aArrayOfParams)
// Constructor takes ownership of aArrayOfParams, but not aName
{}
EXPORT_C CParserProperty::CParserProperty(CArrayPtr<CParserParam>* aArrayOfParams)
: iArrayOfParams(aArrayOfParams)
/** C++ constructor which sets the array of property parameters only.
The property takes ownership of the array of parameters.
@param aArrayOfParams Pointer to the property parameters. */
{}
EXPORT_C void CParserProperty::ConstructSelfL(CParserProperty& aSelf,const TDesC8& aName)
{
if (aName.Length()>0)
{
CleanupStack::PushL(STATIC_CAST(TAny*,&aSelf));
aSelf.SetNameL(aName);
CleanupStack::Pop(&aSelf);
}
}
EXPORT_C CParserProperty* CParserProperty::NewL(CParserPropertyValue& aPropertyValue, const TDesC8& aName, CArrayPtr<CParserParam>* aArrayOfParams)
/** Allocates and constructs a new vCalendar or vCard property with the property
value, property name and array of property parameters specified.
Takes ownership of aPropertyValue and aArrayOfParams.
@param aPropertyValue The property value.
@param aName The property name.
@param aArrayOfParams Pointer to the property parameters.
@return Pointer to the newly created property. */
{
// coverity [alloc_fn]
CParserProperty* self = new(ELeave) CParserProperty(aPropertyValue,aArrayOfParams);
ConstructSelfL(*self,aName);
return self;
}
EXPORT_C CParserProperty::~CParserProperty()
/** Frees all resources owned by the property, prior to its destruction. */
{
TRAPD(errIgnored, VersitUtils::FreeAdditionalPropertyStorageL(*this));
UNUSED_VAR(errIgnored); // used to suppress build warnings
//
delete iPropertyValue;
delete iPropertyName;
if (iArrayOfParams)
{
iArrayOfParams->ResetAndDestroy();
delete iArrayOfParams;
}
}
EXPORT_C void CParserProperty::ExternalizeL(RWriteStream& aStream, CVersitParser* aVersitParser)
/** Externalises a property.
The property has the general format:
\<NAME\>;\<PARAMNAME=PARAMVALUE\>:\<VALUE\>
Checks the property value, and Versit's default encoding and character
set, to decide what encoding, if any, and character set should be applied
to the property value.
If the encoding is not the default, (no encoding), then a parameter (with
the name KVersitTokenENCODING) is added to the property to specify the encoding
used. Similarly, if the character set used is not the default, (Ascii),
then a parameter (with the name KVersitTokenCHARSET) is added
to the property to specify the character set used.
A parser parameter needs to be supplied when calling this function: if NULL
is passed then a panic is raised.
The name is externalised by this function directly. The parameters (if there
are any) are externalised using CParserParam::ExternalizeL(). The value (if
there is one) is externalised using the ExternalizeL() function of the appropriate
property value class.
Using the encoding format and character set selected for the property value,
the function forms a Versit specific UID (Versit::TEncodingAndCharset). When
the property value is externalised, this UID is passed to the property value
class' ExternalizeL() function, so that it knows which character set and encoding
format to use.
Also passed to the ExternalizeL() function of the property value class are
the output stream and the 'output length'. The output stream is the same as
is passed to this function. The 'output length' refers to the amount of data
that has been output to the current line in the stream. This is kept track
of while the property name and parameters are externalised, and then passed
to the ExternalizeL() function of the property value class to make sure the
line length does not exceed the maximum length allowed.
As well as inserting the semi-colon and colon between the name and parameter(s)
and parameter(s) and value, a CRLF is written at the end.
@param aStream Stream to which the value is to be externalised.
@param aVersitParser The Versit parser whose ExternalizeL() function calls
this function, and in whose array of properties this instance of CParserProperty
is held. */
{
if (!iPropertyValue)
return;
__ASSERT_DEBUG(aVersitParser,Panic(EVersitPanicNeedToSpecifyParser));
// Updated in this method
const TUid propertyValueUid(iPropertyValue->Uid());
TBool requiresEncoding = EFalse;
TUint propCharsetId=KCharacterSetIdentifierAscii;
TAny* extPlugIn=NULL;
// Why Daylight?
if (propertyValueUid == TUid::Uid(KVersitPropertyHBufCUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyCDesCArrayUid) ||
propertyValueUid == TUid::Uid(KVCalPropertyAlarmUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyDaylightUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyBinaryUid) ||
propertyValueUid == TUid::Uid(KVCalPropertyExtendedAlarmUid)
)
{
TBool sevenBitsAreSufficient = ETrue;
// This next section checks to see if the buffer passed to CheckEncodings requires a ENCODING=SOMETHING
// line as a property parameter for this item. If it does, then encode is set to ETrue (in most instances...
// Alarms, and Daylight's override any ETrue value to EFalse. Buffers that require this property parameter
// usually contain carriage returns, linefeeds or contain characters that fall outside the 0-127 range
switch(propertyValueUid.iUid)
{
case KVersitPropertyHBufCUid:
{
CParserPropertyValueHBufC* bufValue = STATIC_CAST(CParserPropertyValueHBufC*, iPropertyValue);
//
sevenBitsAreSufficient = VersitUtils::DescriptorContainsOnlySevenBitCharacters(bufValue->Value());
requiresEncoding = VersitUtils::RequiresEncoding(bufValue->Value());
break;
}
case KVersitPropertyCDesCArrayUid:
{
CParserPropertyValueCDesCArray* arrayValue = STATIC_CAST(CParserPropertyValueCDesCArray*, iPropertyValue);
const CDesCArray* value = arrayValue->Value();
if (value)
{
TInt noOfProperties = value->Count();
for (TInt jj = 0; jj < noOfProperties; jj++)
{
TPtrC pValue(value->MdcaPoint(jj));
// Keep local flags
TBool sevenBitsAreSufficientInternal = VersitUtils::DescriptorContainsOnlySevenBitCharacters(pValue);
TBool requiresEncodingInternal = VersitUtils::RequiresEncoding(pValue);
// Now check combined with global flags & update as appropriate
if (!sevenBitsAreSufficientInternal && sevenBitsAreSufficient)
sevenBitsAreSufficient = sevenBitsAreSufficientInternal;
if (requiresEncodingInternal && !requiresEncoding)
requiresEncoding = requiresEncodingInternal;
// Optimisation
if (!sevenBitsAreSufficient && requiresEncoding)
break; // Need both of these, no point checking anymore
}
}
break;
}
case KVCalPropertyAlarmUid:
{
CParserPropertyValueAlarm* bufValue = STATIC_CAST(CParserPropertyValueAlarm*, iPropertyValue);
CVersitAlarm* alarm = bufValue->Value();
if (alarm)
{
if (alarm->iAudioContent)
{
sevenBitsAreSufficient = bufValue->IsAsciiCharacterSetSufficient();
requiresEncoding = VersitUtils::RequiresEncoding(*alarm->iAudioContent);
}
// Only do this check if the audio content can still fit in 7 bits otherwise
// we will need to encode both anyway...
if (alarm->iNote && sevenBitsAreSufficient)
sevenBitsAreSufficient = VersitUtils::DescriptorContainsOnlySevenBitCharacters(*alarm->iNote);
}
break;
}
case KVCalPropertyExtendedAlarmUid:
{
CParserPropertyValueExtendedAlarm* bufValue = STATIC_CAST(CParserPropertyValueExtendedAlarm*, iPropertyValue);
CVersitExtendedAlarm* extendedAlarm = bufValue->Value();
if (extendedAlarm)
{
if (extendedAlarm->iContent)
{
if (extendedAlarm->iDisposition == CVersitExtendedAlarm::EDispositionUrl)
{
sevenBitsAreSufficient = bufValue->IsAsciiCharacterSetSufficient();
}
else
{
sevenBitsAreSufficient = EFalse;
requiresEncoding = ETrue;
}
}
}
break;
}
case KVersitPropertyDaylightUid:
{
// AW: requiresEncoding not used - I'm not sure why
CParserPropertyValueDaylight* bufValue = STATIC_CAST(CParserPropertyValueDaylight*, iPropertyValue);
CVersitDaylight* daylight = bufValue->Value();
if (daylight)
{
if (daylight->iStandardDesignation)
sevenBitsAreSufficient = VersitUtils::DescriptorContainsOnlySevenBitCharacters(*daylight->iStandardDesignation);
// Only do this check if 7 bits was suffient for the standard designation
if (daylight->iDaylightDesignation && sevenBitsAreSufficient)
sevenBitsAreSufficient = VersitUtils::DescriptorContainsOnlySevenBitCharacters(*daylight->iDaylightDesignation);
}
break;
}
case KVersitPropertyBinaryUid:
{
// Not handled here, see further down in the encodings "special case" section
break;
}
default:
__ASSERT_DEBUG(EFalse, User::Invariant());
break;
} // switch
/*
* Work out what character set we need to use for this property.
*
* Always try and use 7 bit ASCII because this is assumed as the default
* and therefore requires no CHARSET parameter.
*
* If ASCII isn't sufficient (see 'sevenBitsAreSufficient'), because there
* are character that can't be represented in ASCII then use the default
* charset instead. However, in the instance where ASCII is also the
* default, then use UTF-8.
*
* UTF-7 overrides all charsets and if specified as the default it should always be
* used in preference to ASCII or any other CHARSET
*/
if (!sevenBitsAreSufficient)
{
propCharsetId = aVersitParser->DefaultCharSetId();
if (propCharsetId == KCharacterSetIdentifierAscii && !iPropertyValue->IsAsciiCharacterSetSufficient())
propCharsetId = KCharacterSetIdentifierUtf8;
}
/*
* If a default encoding has been specified then always use that, regardless of
* whether its required or not.
*/
if (!requiresEncoding && aVersitParser->DefaultEncoding() != Versit::ENoEncoding)
requiresEncoding = ETrue;
} // if
/*
* If the property value is 8 bit (because of the required character set) or the value
* cannot be represented as is (e.g. it might contain CR or LF inside the value) then
* the value must be encoded.
*
* If it's just the charset that's 8bit, then we only need write ENCODING=8-BIT, but
* if it's more complicated because of the property value, then we must use a suitable
* encoding method.
*/
Versit::TVersitEncoding encoding = Versit::ENoEncoding;
if (!aVersitParser->PlugIn() || !aVersitParser->PlugIn()->EncodingType(encoding,requiresEncoding,aVersitParser->DefaultEncoding()
,propertyValueUid,propCharsetId))
{
if (propertyValueUid == TUid::Uid(KVersitPropertyBinaryUid))
{
// A special case - this is encoded using BASE64 *always*
encoding = Versit::EBase64Encoding;
}
else if ((propertyValueUid == TUid::Uid(KVCalPropertyExtendedAlarmUid) && requiresEncoding))
{
encoding = Versit::EBase64Encoding;
}
else if (requiresEncoding)
{
// This is superceeds an 8-bit charset - We will use the default, or
// if none is specified then we'll go with QP.
encoding = aVersitParser->DefaultEncoding();
if (encoding == Versit::ENoEncoding || (propertyValueUid==TUid::Uid(KVCalPropertyAlarmUid) && encoding==Versit::EBase64Encoding))
encoding = Versit::EQuotedPrintableEncoding;
}
else if (VersitUtils::EightBitEncoding(propCharsetId))
{
// It's just an 8 bit charset, no QP or B64 required - Do nothing
encoding = Versit::EEightBitEncoding;
}
else
{
// Don't need any ENCODING=<something> tag - Do nothing
}
/*
* Some properties can't output Base64 data
* this is now corrected so the encoded is specified correctly
*/
if (encoding==Versit::EBase64Encoding)
{
if (propertyValueUid == TUid::Uid(KVersitPropertyTimeZoneUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyDateTimeUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyDateUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyMultiDateTimeUid) ||
propertyValueUid == TUid::Uid(KVersitPropertyIntUid) ||
propertyValueUid == TUid::Uid(KVCalPropertyRecurrenceUid))
{
encoding=Versit::ENoEncoding;
}
}
}
/*
* If we have to add an encoding line parameter, then we do that here. If the encoding
* is BASE64 or QP, then we always write the encoding tag.
*
* In addition, if we're using an 8 bit character set, E.g. ISO-8859-1, then we should
* also add the 8-bit encoding
*/
if (encoding != Versit::ENoEncoding)
{
CParserParam* param = CParserParam::NewL(KVersitTokenENCODING,KNullDesC8);
CleanupStack::PushL(param);
TBool pramAdded=EFalse;
if (aVersitParser->PlugIn())
{
const TDesC8& des=aVersitParser->PlugIn()->EncodingName(encoding);
if (des.Length()>0)
{
param->SetValueL(des);
pramAdded=ETrue;
}
}
if (!pramAdded)
param->SetValueL(VersitUtils::IANAEncodingName(encoding));
AddParamL(param); // takes ownership
CleanupStack::Pop(param);
if (encoding==Versit::EEightBitEncoding)
encoding=Versit::ENoEncoding;
}
else
{// delete the ENCODING parameter if it was there
TPtrC8 bufEncoding(KVersitTokenENCODING);
DeleteParam(bufEncoding);
}
/*
* We now combine the encoding (if any) with the character set to form
* a versit specific uid which represents both of these things in one
* value.
*
* This uid is passed to the property value when it's externalized, and
* used to ensure that any text is written in the correct character set
* and with the correct encoding.
*
*/
Versit::TEncodingAndCharset encodingAndCharset(encoding,propCharsetId);
aVersitParser->SetCharacterConverter(encodingAndCharset);
/*
* In the instance where ASCII representation is not sufficient, it is necessary to create
* an extra property parameter which indicates the CHARSET that was used during the
* export process.
*/
/*
* vCard 3.0 format allows automatic CHARSET parameter export to be disabled.
* And to generate a content line in the format <NAME>;<PARAMNAME=PARAMVALUE>:<VALUE> ,
* lines longer than 75 characters SHOULD be folded as defined by RFC2425 and RFC2426.
*/
TBool disableCharset=EFalse;
if (aVersitParser->PlugIn())
{
aVersitParser->PlugIn()->GetInterface(KUidVersitPlugInExtension, extPlugIn);
if (extPlugIn)
{
disableCharset = static_cast<MVersitPlugInExtension*>(extPlugIn)->DisableCharsetParam();
}
}
if (propCharsetId != KCharacterSetIdentifierAscii && !disableCharset)
{
CParserParam* param = CParserParam::NewL(KVersitTokenCHARSET,KNullDesC8);
CleanupStack::PushL(param);
HBufC8* standardName = aVersitParser->UnicodeUtils().StandardNameL(propCharsetId);
if (standardName->CompareF(KVersitTokenUTF8()) == 0)
{
standardName->Des().Fold();
}
param->SetValueL(standardName);
AddParamL(param);
CleanupStack::Pop(param);
}
else
{// delete the CHARSET parameter if it was there
TPtrC8 bufCharset(KVersitTokenCHARSET);
DeleteParam(bufCharset);
}
/*
* General format is:
*
* <NAME>;<PARAMNAME=PARAMVALUE>:<VALUE>
*
*/
TBool foldParam=EFalse;
if (extPlugIn)
{
foldParam = static_cast<MVersitPlugInExtension*>(extPlugIn)->FoldParam();
}
// Write out NAME part
TInt outputLen = 0;
if(foldParam)
{
HBufC8* name = Name().AllocLC();
TPtr8 text(name->Des());
aVersitParser->PlugIn()->WrapLine(aStream, outputLen, text);
CleanupStack::PopAndDestroy(name);
}
else
{
aStream.WriteL(Name());
outputLen = Name().Length();
}
// Write out PARAMNAME=PARAMVALUE part
if (iArrayOfParams)
{
TInt noOfParams = iArrayOfParams->Count();
for (TInt ii = 0; ii < noOfParams; ii++)
{
aStream.WriteL(KVersitTokenSemiColon);
if(foldParam)
{
outputLen++; //1 for the ";"
iArrayOfParams->At(ii)->ExternalizeL(aStream, outputLen, aVersitParser);
}
else
{
outputLen += iArrayOfParams->At(ii)->ExternalizeL(aStream)+1;
}
}
}
// Write out VALUE part
aStream.WriteL(KVersitTokenColon);
outputLen++; //1 for the ":"
iPropertyValue->ExternalizeL(aStream, encodingAndCharset, outputLen);
aStream.WriteL(KVersitTokenCRLF);
}
EXPORT_C CParserParam* CParserProperty::Param(const TDesC8& aParamName) const
// return first parameter found with specified name
/** Gets a pointer to the property parameter with the specified name.
If the property has more than one parameter with the same name, the function
returns the one nearest the start of the array, but there should never be
more than one of each possible parameter.
@param aParamName The name of the parameter to search for.
@return Pointer to a property parameter. NULL if the parameter name specified
is not found in the array. */
{
if (iArrayOfParams)
{
TInt count = iArrayOfParams->Count();
for (TInt ii = 0; ii < count; ii++)
{
if ((*iArrayOfParams)[ii]->Name().CompareF(aParamName) == 0)
return ((*iArrayOfParams)[ii]);
}
}
return NULL;
}
EXPORT_C CArrayPtr<CParserParam>* CParserProperty::ParamArray()const
/** Returns a pointer to the array of property parameters.
@return Pointer to array of property parameters. NULL if the property is not having any parameters.*/
{
//if the array doesn't exist, return NULL.
if(!iArrayOfParams)
{
return NULL;
}
return iArrayOfParams;
}
EXPORT_C void CParserProperty::AddParamL(CParserParam* aParam)
/** Adds a property parameter to the property.
Any existing parameter with the same name is replaced. The parameter is appended
to the property's parameter array. If no property parameter array has been
allocated, the function will first allocate one.
@param aParam Pointer to a generic property parameter, consisting of a name
and optionally a value, both specified as descriptors. The property takes
ownership of the new parameter. */
{
TPtrC8 name=aParam->Name();
DeleteParam(name);
// if the array doesn't exist, create one here
if (!iArrayOfParams)
iArrayOfParams = new(ELeave)CArrayPtrFlat<CParserParam>(4);
iArrayOfParams->AppendL(aParam);
}
EXPORT_C void CParserProperty::DeleteParam(TDesC8& aParamName)
/** Deletes the specified property parameter from the property's array of parameters,
if it exists in the array.
If the property has more than one parameter with the same name, the function
deletes the one nearest the start of the array, but there should never be
more than one of each possible parameter.
@param aParamName The name of the parameter to delete. */
{
if (iArrayOfParams)
{
const TInt count = iArrayOfParams->Count();
for (TInt ii = 0; ii < count; ii++)
{
if ((*iArrayOfParams)[ii]->Name() == aParamName)
{
delete (*iArrayOfParams)[ii];
iArrayOfParams->Delete(ii);
break;
}
}
}
}
EXPORT_C void CParserProperty::SetNameL(const TDesC8& aName)
/** Sets the property name.
If a name has already been set, this function will replace it.
This function allocates and constructs a new heap descriptor
and initialises it using the content of aName, so can leave if insufficient
memory is available.
@param aName The new property name. Property names are defined in vtoken.h. */
{
delete iPropertyName;
iPropertyName = NULL;
iPropertyName = aName.AllocL();
}
EXPORT_C TBool CParserProperty::SupportsInterface(const TUid& /*aInterfaceUid*/) const
/** Tests whether the property value supports the specified interface.
This implementation returns EFalse.
@param aInterfaceUid Not used.
@return EFalse. */
{
return EFalse;
}
EXPORT_C TPtrC8 CParserProperty::Name() const
/** Gets the property name.
If no name has been set, the function returns an empty descriptor.
@return The property name. */
{
if (iPropertyName)
return iPropertyName->Des();
return KVersitTokenEmptyNarrow();
}
EXPORT_C TBool CParserProperty::SaveBinaryValuesToFilesL(TInt aSizeThreshold,const TDesC& aPath,RFs& aFileSession)
/** If the property value is binary and is larger than the specified threshold,
this function saves the binary data to a file and sets the property value
to be a URI representing the file rather than the binary data iself.
If the property value is not binary, or if it is binary, but is smaller than
the threshold, the function just returns EFalse.
The file is created in the folder identified by aPath, and is assigned a unique
filename that consists of the property name and some random numbers.
The new URI property value is prefixed with file:// and contains the path
and filename of the file created.
The function uses the file server session supplied, which is needed to create
the files. It leaves if there is a problem creating any of the files.
This function is used by CVersitParser::SaveBinaryValuesToFilesL().
@param aSizeThreshold The threshold number of bytes for the binary data, above
which a file is created and the binary data is stored in it.
@param aPath The path identifying the location in which the file is created.
Must not be greater than 240 characters long or the function leaves with KErrArgument.
If it doesn't end in a slash, then one is appended.
@param aFileSession The file server session used to create the files.
@return ETrue if the property value is binary and its size is greater than
the threshold. EFalse if not. */
{
// The length of the path can be maximum 240 characters.
__ASSERT_ALWAYS((aPath.Length() <= (KMaxFileName - KMaxGeneratedfilenamelen)),User::Leave(KErrArgument));
if (iPropertyValue->Uid().iUid==KVCardPropertyAgentUid)
{
return ((static_cast<CParserPropertyValueAgent*>(iPropertyValue)->Value())->SaveBinaryValuesToFilesL(aSizeThreshold,aPath,aFileSession));
}
else if (iPropertyValue->Uid().iUid!=KVersitPropertyBinaryUid)
{
return EFalse;
}
const CBufSeg* bufseg_ptr = static_cast<CParserPropertyValueBinary*>(iPropertyValue)->Value();
if (!bufseg_ptr || bufseg_ptr->Size() <= aSizeThreshold)
{
return EFalse;
}
// read the binary data into a buffer so as to create and write to a file later on
HBufC8* buffer = HBufC8::NewL(0);
CleanupStack::PushL(TCleanupItem(DestroyHBufC, &buffer));
ReadBinaryDataL(bufseg_ptr, &buffer);
// create a file . The file name is generated with the function call and then the file is created
TBuf<KMaxFileName + KFileProtocolStringLength> filename(aPath);
RFile file;
GenerateNameAndCreateFileL(aFileSession, iPropertyName->Des(), file, filename);
// Write the binary value to the file.
CleanupClosePushL(file);
User::LeaveIfError(file.Write(*buffer));
// pop and destroy the file and the buffer objects
CleanupStack::PopAndDestroy(2);
// Convert the filename to a URI in accordance with RFC 1738: prefix "file://" and change all \s to /s.
filename.Insert(0,KFileProtocol);
const TInt fileNameLength = filename.Length();
for (TInt i = KFileProtocolStringLength; i < fileNameLength; i++)
{
if (filename[i] == '\\')
{
filename[i] = '/';
}
}
CDesCArrayFlat* desarray = new(ELeave) CDesCArrayFlat(filename.Length());
CleanupStack::PushL(desarray);
TPtrC ptrc(filename);
desarray->InsertL(0,ptrc);
CParserPropertyValueCDesCArray* value = new(ELeave) CParserPropertyValueCDesCArray(desarray);
CleanupStack::Pop(desarray);
CleanupStack::PushL(value);
// Add a parameter identifying the property value as a URI.
CParserParam* uripropertyparam = CParserParam::NewL(KValue,KUri);
CleanupStack::PushL(uripropertyparam);
AddParamL(uripropertyparam);
CleanupStack::Pop(uripropertyparam);
// Remove any other value parameters. The new parameter is the last one.
const TInt count = iArrayOfParams->Count();
for (TInt ii = 0; ii < count; ii++)
{
if ((*iArrayOfParams)[ii]->Name() == KValue)
{
if (ii == (count-1))
{
break;
}
else
{
delete (*iArrayOfParams)[ii];
iArrayOfParams->Delete(ii);
}
}
}
delete iPropertyValue;
iPropertyValue = value;
CleanupStack::Pop(value);
return ETrue;
}
EXPORT_C TBool CParserProperty::LoadBinaryValuesFromFilesL(RFs& aFileSession)
/** If the property value is a URI, this function loads the file represented by
the URI and sets the binary data it contains to be the property value, instead
of the URI.
If the property value is not a URI, the function just returns EFalse.
The function also operates on any agents in a vCard that contain URI property
values.
The function uses the file server session supplied, which is needed to open
the files. It leaves if there is a problem opening any of the files.
This function is used by CVersitParser::LoadBinaryValuesFromFilesL().
@param aFileSession The file server session used to open the files.
@return ETrue if the property value is a URI, EFalse if not. */
{
if (iPropertyValue->Uid().iUid==KVCardPropertyAgentUid)
{
return ((static_cast<CParserPropertyValueAgent*>(iPropertyValue)->Value())->LoadBinaryValuesFromFilesL(aFileSession));
}
// Do nothing if the value is not a text value .
else if (iPropertyValue->Uid().iUid!=KVersitPropertyCDesCArrayUid)
{
return EFalse;
}
CDesCArray* text_ptr = static_cast<CParserPropertyValueCDesCArray*>(iPropertyValue)->Value();
if (text_ptr == NULL)
{
return EFalse;
}
const TDesC& text = text_ptr->MdcaPoint(0);
//The URI should contain file:// and some filename with path.. The min file name would be eg. c:\<1digitnumber>
if ((text.Length() < (KFileProtocolStringLength + KMinFileNameLen)) || (text.Left(KFileProtocolStringLength).CompareF(KFileProtocol) != 0))
{
return EFalse;
}
// Do nothing if this is not a URI value representing a file.
const CParserParam* param = Param(KValue);
if (param == NULL || ( param->Value().CompareF(KUri) != 0))
{
return EFalse;
}
// Convert the URI to a filename: remove "file://" and change /s to \s.
TPtrC fptrc = text.Mid(KFileProtocolStringLength);
if (fptrc.Length() > KMaxFileName)
{
fptrc.Set(fptrc.Ptr(),KMaxFileName);
}
TFileName filename(fptrc);
const TInt filenameLength = filename.Length();
for (TInt i = 0; i < filenameLength; i++)
{
if (filename[i] == '/')
{
filename[i] = '\\';
}
}
// Load the file and put it into a CVersitBinaryValue.
RFile file;
User::LeaveIfError(file.Open(aFileSession,filename,EFileRead));
CleanupClosePushL(file);
TInt bytes;
User::LeaveIfError(file.Size(bytes));
HBufC8* buffer = HBufC8::NewL(bytes);
CleanupStack::PushL(TCleanupItem(DestroyHBufC, &buffer));
TPtr8 des(buffer->Des());
User::LeaveIfError(file.Read(des));
__ASSERT_ALWAYS((buffer->Length() >= bytes),User::Leave(KErrGeneral));
CParserPropertyValueBinary* value = CParserPropertyValueBinary::NewL(buffer->Left(buffer->Length()));
// pop and destroy the file and the buffer objects
CleanupStack::PopAndDestroy(2);
//There should only ever be one VALUE parameter, and, in order have gotten to
// this point in the code, it has to be value=URI
// so we just delete all VALUE parameters (there should only be one, but this handles
// corrupt data better, even though it is a bit slower).
const TInt count = iArrayOfParams->Count();
for (TInt ii = 0; ii < count; ii++)
{
if ((*iArrayOfParams)[ii]->Name() == KValue)
{
delete (*iArrayOfParams)[ii];
iArrayOfParams->Delete(ii);
}
}
// Replace the existing value with the new binary value.
delete iPropertyValue;
iPropertyValue = value;
return ETrue;
}
/*
* Reads the binary data from the segmented buffer onto a heap descriptor
*
*
* @param "const CBufSeg* aBufseg_ptr" ( source )
* The segemnted buffer that contains the binary data
* @param "HBufC8** aBuffer" ( destination )
* The pointer to the heap descriptor data location which
* eventually holds the data
* A ptr to ptr is passed since the reloaction is happening inside
*/
void CParserProperty::ReadBinaryDataL(const CBufSeg* aBufseg_ptr,HBufC8** aBuffer)
{
TInt buf_size = aBufseg_ptr->Size();
TInt pos = 0;
TInt len = 0;
while ( pos < buf_size)
{
len =const_cast<CBufSeg*>(aBufseg_ptr)->Ptr(pos).Length();
TUint8* temp = new (ELeave) TUint8 [len];
CleanupArrayDeletePushL(temp);
aBufseg_ptr->Read(pos,temp,len);
// copy the data to the buffer
*aBuffer = (*aBuffer)->ReAllocL(pos+len);
TPtr8 localptr = (*aBuffer)->Des();
localptr.Append(const_cast<TUint8*>(temp),len);
//continue the iteration
pos += len;
CleanupStack::PopAndDestroy(temp);
}
return;
}
/*
* Creates a file. The name of the file is generated using the following parameters
* <propertyname limited in length if required depending on the length of the path>
* <a randomly generated number which is max upto 5 characters in len>
* The path is specified as an input to teh fuction which is used in creating a file.
*
* @param "RFs& aFileSession"
* The file server session to be used
* @param "TPtr8 aPropertyName"
* The property name that holds the binary data
* @param "RFile& aFile"
* The handle to the file created
* @param "TDes& aFileName"
* The name of the file created. Initially this contains the path when it is passed to the function.
* Inside teh function the filename is appended
*/
void CParserProperty::GenerateNameAndCreateFileL(RFs& aFileSession, TPtr8 aPropertyName, RFile& aFile, TDes& aFileName)
{
// the total space available to store the path+ filename = 256 ( KMaxFileName)
// aFileName.Length() gives the length of the path
// hence available length for filename ( propertyname + 5 digit randomnumber ) = 256 - aFileName.Length()
TInt available = (KMaxFileName - aFileName.Length());
if (aFileName[aFileName.Length() - 1] != '\\')
{
aFileName.Append('\\');
available--;
}
// gets the property name into a TPtrC
TInt proplen = aPropertyName.Length();
HBufC* propertyname = HBufC::NewL(proplen);
CleanupStack::PushL(TCleanupItem(DestroyHBufC, &propertyname));
TPtr propnameptr = propertyname->Des();
propnameptr.Copy(aPropertyName);
TPtrC name(propertyname->Left(proplen));
// limit the property name so that u limit the path+filename = 256 characters
if (name.Length() > available - KRandomnumberlen)
{
name.Set(name.Ptr(),available - KRandomnumberlen);
}
aFileName.Append(name);
CleanupStack::PopAndDestroy(&propertyname);
// Fill in any missing parts of the filename.
TParse parse;
User::LeaveIfError(aFileSession.Parse(aFileName,parse));
aFileName = parse.FullName();
TTime time;
time.UniversalTime();
TInt64 seed = time.Int64();
TInt length = aFileName.Length();
TInt n;
FOREVER
{
n = Math::Rand(seed) >> 16;
aFileName.AppendNum(n);
TInt error = aFile.Create(aFileSession,aFileName,EFileWrite);
if(error == KErrNone)
{
break;
}
else
{
__ASSERT_ALWAYS((error == KErrAlreadyExists),User::Leave(error));
}
aFileName.SetLength(length);
}
return;
}
EXPORT_C void CParserProperty::Reserved()
{}