diff -r 000000000000 -r 3553901f7fa8 telephonyserver/etelmultimode/CETEL/mm_pbutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserver/etelmultimode/CETEL/mm_pbutil.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,563 @@ +// 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 // for RMobilePhoneBookStore +#include "mpbutil.h" + +const TUint8 KTagPadZeroValue = 0x00; + +EXPORT_C CPhoneBookBuffer::CPhoneBookBuffer() : iMonitor(NULL,0,0) +/** The CPhoneBookBuffer library class is constructed using a simple, one-phase +constructor because the CPhoneBookBuffer class does not allocate any member +data on the heap. */ + { + } + +EXPORT_C void CPhoneBookBuffer::Set(TDes8* aBuf) +/** This member function sets the buffer's internal attribute iPtr to point to +the supplied 8-bit buffer, which is owned by the caller of this function member. + +@param aData A pointer to the buffer +@capability None +*/ + { + iPtr = aBuf; + } + +EXPORT_C TInt CPhoneBookBuffer::AddNewEntryTag() +/** This function member puts a new entry tag byte (ETagPBNewEntry) into the buffer + and sets iMonitor to point to the beginning of each new entry. + +@return KErrNone if successful, or KErrOverflow if there is not enough space +in the buffer. +@see RMobilePhoneBookStore::TMobilePBFieldTags +@capability None +*/ + { + // First check whether there is enough space to fit new entry tag + if( (iPtr->MaxLength() - iPtr->Length()) > 1 ) + { + AppendInt8(RMobilePhoneBookStore::ETagPBNewEntry); + const TInt len = iPtr->Length(); + // Make sure iMonitor has been updated and it points to the beggining of the new entry + iMonitor.Set(&(*iPtr)[len-1], iPtr->MaxLength() - len + 1, iPtr->MaxLength() - len + 1); + return KErrNone; + } + else + { + return KErrOverflow; + } + } + +EXPORT_C TInt CPhoneBookBuffer::AddNewNumberTag() +/** This function member puts a new number tag byte (ETagPBAnrStart) into the buffer. + + +@return KErrNone if successful, or KErrOverflow if there is not enough space +in the buffer. +@see RMobilePhoneBookStore::TMobilePBFieldTags +@capability None +*/ + { + // First check whether there is enough space to fit new entry tag + if( (iPtr->MaxLength() - iPtr->Length()) > 1 ) + { + AppendInt8(RMobilePhoneBookStore::ETagPBAnrStart); + return KErrNone; + } + else + { + return KErrOverflow; + } + } + + +/** + * Puts a 8-bit integer value into buffer. + * + * The valid tags for use with 8-bit integers are: + * + * @li RMobilePhoneBookStore::ETagPBBearerCap + * @li RMobilePhoneBookStore::ETagPBEntryControl + * @li RMobilePhoneBookStore::ETagPBHiddenInfo + * @li RMobilePhoneBookStore::ETagPBTonNpi + * @li RMobilePhoneBookStore::ETagPBUniqueId + * @li RMobilePhoneBookStore::ETagPBEntryStatus + * + * @param aTagValue Tag byte to use. + * @param aInteger Value to put in the buffer. + * + * @return KErrNone if successful, KErrOverflow if there is not enough + * space in the buffer or KErrArgument if the parameter is invalid. + * + * @capability None + */ +EXPORT_C TInt CPhoneBookBuffer::PutTagAndValue(TUint8 aTagValue, TUint8 aInteger) + { + // + // Check that the tag type is valid for this type of value... + // + if (aTagValue != RMobilePhoneBookStore::ETagPBBearerCap && + aTagValue != RMobilePhoneBookStore::ETagPBEntryControl && + aTagValue != RMobilePhoneBookStore::ETagPBHiddenInfo && + aTagValue != RMobilePhoneBookStore::ETagPBTonNpi && + aTagValue != RMobilePhoneBookStore::ETagPBUniqueId && + aTagValue != RMobilePhoneBookStore::ETagPBEntryStatus) + { + return KErrArgument; + } + + // First need to ensure that aInteger can fit into the supplied buffer + if((iPtr->MaxLength()-iPtr->Length()) > 2) + { + AppendInt8(aTagValue); + AppendInt8(aInteger); + return KErrNone; + } + else + { + return KErrOverflow; + } + } + + +/** + * Puts a 16-bit integer value into buffer. + * + * The valid tags for use with 16-bit integers are: + * + * @li RMobilePhoneBookStore::ETagPBAdnIndex + * + * @param aTagValue Tag byte to use. + * @param aInteger Value to put in the buffer. + * + * @return KErrNone if successful, KErrOverflow if there is not enough + * space in the buffer or KErrArgument if the parameter is invalid. + * + * @capability None + */ +EXPORT_C TInt CPhoneBookBuffer::PutTagAndValue(TUint8 aTagValue, TUint16 aInteger) + { + // + // Check that the tag type is valid for this type of value... + // + if (aTagValue != RMobilePhoneBookStore::ETagPBAdnIndex) + { + return KErrArgument; + } + + // First need to ensure that aInteger can fit into the supplied buffer + if((iPtr->MaxLength()-iPtr->Length()) > 3) + { + AppendInt8(aTagValue); + AppendInt16(aInteger); + return KErrNone; + } + else + { + return KErrOverflow; + } + } + + +/** + * Puts a 32-bit integer value into buffer. + * + * The valid tags for use with 32-bit integers are: + * + * @li None. + * + * @param aTagValue Tag byte to use. + * @param aInteger Value to put in the buffer. + * + * @return KErrNone if successful, KErrOverflow if there is not enough + * space in the buffer or KErrArgument if the parameter is invalid. + * + * @capability None + */ +EXPORT_C TInt CPhoneBookBuffer::PutTagAndValue(TUint8 aTagValue, TUint32 aInteger) + { + // + // No Tags support 32bit integers... + // + (void) aTagValue; + (void) aInteger; + + return KErrArgument; + +// // First need to ensure that aInteger can fit into the supplied buffer +// if((iPtr->MaxLength()-iPtr->Length()) > 5) +// { +// AppendInt8(aTagValue); +// AppendInt32(aInteger); +// return KErrNone; +// } +// else +// { +// return KErrOverflow; +// } + } + + +/** + * Puts a 16-bit descriptor value into buffer. + * + * The valid tags for use with 16-bit descriptors are: + * + * @li RMobilePhoneBookStore::ETagPBSecondName + * @li RMobilePhoneBookStore::ETagPBGroupName + * @li RMobilePhoneBookStore::ETagPBEmailAddress + * @li RMobilePhoneBookStore::ETagPBText + * @li RMobilePhoneBookStore::ETagPBNumber + * + * @param aTagValue Tag byte to use. + * @param aData Value to put in the buffer. + * + * @return KErrNone if successful, KErrOverflow if there is not enough + * space in the buffer or KErrArgument if the parameter is invalid. + * + * @capability None + */ +EXPORT_C TInt CPhoneBookBuffer::PutTagAndValue(TUint8 aTagValue, const TDesC16 &aData) + { + // + // Check that the tag type is valid for this type of value... + // + if (aTagValue != RMobilePhoneBookStore::ETagPBSecondName && + aTagValue != RMobilePhoneBookStore::ETagPBGroupName && + aTagValue != RMobilePhoneBookStore::ETagPBEmailAddress && + aTagValue != RMobilePhoneBookStore::ETagPBText && + aTagValue != RMobilePhoneBookStore::ETagPBNumber) + { + return KErrArgument; + } + + // First need to ensure that aData can fit into the supplied buffer + // Need to use Size() because this is Unicode data and we want to know number of bytes not number of characters + // Also allow for the 1-byte tag and up to 3 zero padding bytes + if((aData.Size()+3 <= KMaxUint16Val) && ((iPtr->MaxLength()-iPtr->Length()) > (aData.Size()+4))) + { + // Make sure buffer is word aligned after adding 3 bytes for tag and length + switch(iPtr->Size()%4) + { + case 0: + AppendInt8(KTagPadZeroValue); + break; + case 1: + break; + case 2: + AppendInt8(KTagPadZeroValue); + AppendInt8(KTagPadZeroValue); + AppendInt8(KTagPadZeroValue); + break; + case 3: + AppendInt8(KTagPadZeroValue); + AppendInt8(KTagPadZeroValue); + break; + default: + break; + } + + AppendInt8(aTagValue); + TUint16 len=(TUint16) aData.Size(); + iPtr->Append((const TUint8*)&len,2); + TUint8* dataPtr=reinterpret_cast(const_cast(aData.Ptr())); + iPtr->Append(dataPtr,len); + return KErrNone; + } + else + { + return KErrOverflow; + } + } + + +/** + * Puts a 8-bit descriptor value into buffer. + * + * The valid tags for use with 8-bit descriptors are: + * + * @li None. + * + * @param aTagValue Tag byte to use. + * @param aData Value to put in the buffer. + * + * @return KErrNone if successful, KErrOverflow if there is not enough + * space in the buffer or KErrArgument if the parameter is invalid. + * + * @capability None + */ +EXPORT_C TInt CPhoneBookBuffer::PutTagAndValue(TUint8 aTagValue, const TDesC8 &aData) + { + // + // No Tags support 8bit text... + // + (void) aTagValue; + (void) aData; + + return KErrArgument; + +// // First need to ensure that aData can fit into the supplied buffer +// if((aData.Size() <= KMaxUint16Val) && ((iPtr->MaxLength()-iPtr->Length()) > (aData.Size()+1))) +// { +// AppendInt8(aTagValue); +// TUint16 len=(TUint16) aData.Length(); +// iPtr->Append((const TUint8*)&len,2); +// iPtr->Append(aData); +// return KErrNone; +// } +// else +// { +// return KErrOverflow; +// } + } + +EXPORT_C TInt CPhoneBookBuffer::RemovePartialEntry() +/**This function will rollback the buffer to the end of the last complete +phonebook entry and remove any data after this. + +@return KErrNone if successful. +@capability None +*/ + { + iPtr->SetLength(iPtr->MaxLength() - iMonitor.Length()); + iMonitor.FillZ(); + return KErrNone; + } + +EXPORT_C void CPhoneBookBuffer::StartRead() +/** This function member sets the CPhoneBookBuffer class' iRead member data to +point to the start of the populated TLV buffer, ready to start data extraction +from the buffer. +@capability None +*/ + { + iRead.Set(*iPtr); + } + +EXPORT_C TInt CPhoneBookBuffer::GetTagAndType(TUint8 &aTagValue, TPhBkTagType &aDataType) +/** This function member reads the next tag value from the buffer. + +@param aTagValue On completion, the next Tag type from the buffer. +@param aDataType On completion, the data type associated with the tag value. +@return KErrNone if successful, or KErrNotFound if there are no more tags in +the buffer. +@capability None +*/ + { + // Check we've not reached end of buffer - if we have then return + TInt length = iRead.Length(); + + if (length<=0) + return KErrNotFound; + + // Extract all padding zero bytes until tag is found + TInt i=0; + do + { + aTagValue=iRead[i++]; + } + while ((aTagValue==KTagPadZeroValue) && i(const_cast(iRead.Ptr())); + + aData.Set(dataPtr,len); + + iRead.Set(iRead.Mid(size)); + return KErrNone; + } + +EXPORT_C TInt CPhoneBookBuffer::BufferLength() +/** This function member returns the length of the populated buffer. + +@return The buffer length. +@capability None +*/ + { + return iPtr->Length(); + } + +EXPORT_C TInt CPhoneBookBuffer::RemainingReadLength() +/** This function member returns the length of the remaining data to read in the +populated buffer. + +@return The length of the remaining data. +@capability None +*/ + { + return iRead.Length(); + } + +EXPORT_C void CPhoneBookBuffer::SkipValue(TPhBkTagType aDataType) +/** This function member skips the next value in the buffer that is waiting to +be read. Clients would use this function member if they do not support the +field contained in the next data value. + +@param aDataType The data type of the value to skip +@capability None +*/ + { + TUint16 size=0; + switch (aDataType) + { + case EPhBkTypeInt8: + iRead.Set(iRead.Mid(1)); + break; + case EPhBkTypeInt16: + iRead.Set(iRead.Mid(2)); + break; + case EPhBkTypeInt32: + iRead.Set(iRead.Mid(4)); + break; + case EPhBkTypeDes8: + case EPhBkTypeDes16: + size=(TUint16)((iRead[1]<<8)+iRead[0]); // Dependant upon endianess + iRead.Set(iRead.Mid(2+size)); + break; + default: + // EPhBkTypeNoData caught here - no data to skip, so do nothing + break; + } + } + +TInt CPhoneBookBuffer::AppendInt8(TUint8 aInteger) + { + const TUint8* intAddr=(const TUint8*)&aInteger; + iPtr->Append(intAddr,1); + return KErrNone; + } + +TInt CPhoneBookBuffer::AppendInt16(TUint16 aInteger) + { + const TUint8* intAddr=(const TUint8*)&aInteger; + iPtr->Append(intAddr,2); + return KErrNone; + } + +TInt CPhoneBookBuffer::AppendInt32(TUint32 aInteger) + { + const TUint8* intAddr=(const TUint8*)&aInteger; + iPtr->Append(intAddr,4); + return KErrNone; + }