diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/sendas/client/src/csendasaccounts.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/sendas/client/src/csendasaccounts.cpp Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,291 @@ +// Copyright (c) 2004-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 +#include + +const TInt KMessageAccountArrayGranularity = 8; +const TInt16 KStreamVersionSendAs2Account = 1; +const TInt KMaxSendAs2AccountNameLength = 1024; + +/** +Create a new CSendAsAccount. + +@return +If the function succeeds, this is a pointer to a newly allocated and initialised +object. +*/ +EXPORT_C CSendAsAccounts* CSendAsAccounts::NewL() + { + CSendAsAccounts *self = new (ELeave) CSendAsAccounts; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +/** +Destructor. +*/ +EXPORT_C CSendAsAccounts::~CSendAsAccounts() + { + delete iAccountNames; + iAccounts.Close(); + } + +/** +The UID of the message type. + +@return +The UID of the message type. +*/ +EXPORT_C TUid CSendAsAccounts::MessageType() const + { + return iMessageType; + } + +/** +The array of names of accounts for this message type. + +@return +An array of name of accounts. +*/ +EXPORT_C const MDesCArray& CSendAsAccounts::AccountNames() const + { + return (*iAccountNames); + } + +/** +The account specified by the index argument. + +@param aIndex +The index of the specified account. + +@return +The account specified by the index argument. +*/ +EXPORT_C TSendAsAccount CSendAsAccounts::Account(TInt aIndex) const + { + return iAccounts[aIndex]; + } + +/** +The number of accounts for this message type. + +@return +The number of accounts. +*/ +EXPORT_C TInt CSendAsAccounts::Count() const + { + return iAccountNames->Count(); + } + +/** +Deletes all elements from the array. +*/ +EXPORT_C void CSendAsAccounts::Reset() + { + iAccountNames->Reset(); + iAccounts.Reset(); + } + +/** +The name associated with the given account. + +@param aAccount +The account whose associated name is to be returned. + +@return +A descriptor holding the associated name. +*/ +EXPORT_C TPtrC CSendAsAccounts::NameFromAccountL(const TSendAsAccount aAccount) const + { + TInt nameIndex = User::LeaveIfError(iAccounts.Find(aAccount)); + return (*iAccountNames)[nameIndex]; + } + +/** +The account associated with the given name. + +@param aName +The associated name for the account to be returned. + +@return +An account for the associated name. + +@leave KErrNotFound +An account with the given name cannot be found. +*/ +EXPORT_C TSendAsAccount CSendAsAccounts::AccountFromNameL(const TDesC& aName) const + { + TInt acctIndex; + if (iAccountNames->Find(aName, acctIndex) != 0) + { + User::Leave(KErrNotFound); + } + return iAccounts[acctIndex]; + } + +/** +Internalizes the object from the specified stream. + +@see +RMsvReadStream + +@param aReadStream +The stream to read from. + +@internalComponent +*/ +EXPORT_C void CSendAsAccounts::InternalizeL(RReadStream& aReadStream) + { + aReadStream.ReadInt16L(); // version - not used yet + + aReadStream >> iMessageType; + + TInt count = aReadStream.ReadInt32L(); + + Reset(); + + TSendAsAccount sendAsAccount; + for (TInt i = 0; i < count; ++i) + { + HBufC* buf = HBufC::NewLC(aReadStream, KMaxSendAs2AccountNameLength); + aReadStream >> sendAsAccount; + AppendAccountL(*buf, sendAsAccount); + + CleanupStack::PopAndDestroy(buf); + } + } + + +/** +Externalizes the object from the specified stream. + +@see +RMsvWriteStream + +@param aWriteStream +The stream to write out to. + +@internalComponent +*/ +EXPORT_C void CSendAsAccounts::ExternalizeL(RWriteStream& aWriteStream) const + { + __ASSERT_ALWAYS((iAccountNames->Count() == iAccounts.Count()), User::Invariant()); + + aWriteStream.WriteInt16L(KStreamVersionSendAs2Account); // Version number + aWriteStream << iMessageType; // Message type + + TInt count = iAccountNames->Count(); + aWriteStream.WriteInt32L(count); // The count of name, uid object pairs to write out. + + for (TInt i = 0; i < count; ++i) + { + if ((*iAccountNames)[i].Length() > KMaxSendAs2AccountNameLength) + { + // Limit the string length if necessary. + aWriteStream.WriteL((*iAccountNames)[i], KMaxSendAs2AccountNameLength); + } + else + { + aWriteStream << (*iAccountNames)[i]; + } + aWriteStream << iAccounts[i]; + } + } + +/** +Sets UID of the message type. + +@param aMessageType +The UID of the message type. +*/ +EXPORT_C void CSendAsAccounts::SetMessageType(TUid aMessageType) + { + iMessageType = aMessageType; + } + +/** +Appends a new account and associated name pair. + +@param aAccountName +The human readable name with which to associate with the given account. + +@param aAccount +The account to add. +*/ +EXPORT_C void CSendAsAccounts::AppendAccountL(const TDesC& aAccountName, TSendAsAccount aAccount) + { + iAccounts.AppendL(aAccount); + TRAPD(err, iAccountNames->AppendL(aAccountName)); + if (err != KErrNone) + { + iAccounts.Remove(iAccounts.Count() - 1); + User::Leave(err); + } + } + +/** +Removes an existing account and associated name pair. + +@param aIndex +The index of the entry to remove. +*/ +EXPORT_C void CSendAsAccounts::RemoveAccount(TInt aIndex) + { + iAccountNames->Delete(aIndex); + iAccounts.Remove(aIndex); + } + +/** +Gives the size of the accounts collection. + +@return +The size of the accounts collection. +*/ +EXPORT_C TInt CSendAsAccounts::Size() const + { + const TInt acctSize(sizeof(TSendAsAccount)); + const TInt tIntSize(sizeof(TInt)); + TInt totalSize = sizeof(TInt16) + sizeof(TUid); // The version and message type. + TInt count = iAccountNames->Count(); + + totalSize += tIntSize; // Size of the number of accounts + + for (TInt i = 0; i < count; ++i) + { + // Each account consists of an integer which tells us the size of the + // account name, the account name, and the the TSendAsAccount data. We must + // add the size of each of these items to the total. + // Note that when externalizing an account, we don't explicitly write out an + // integer containing the size of the account name, but the externalize + // routine for the descriptor will write one out, so we must include it in + // our calculation here. + totalSize += tIntSize + (*iAccountNames)[i].Size() + acctSize; + } + + return totalSize; + } + +CSendAsAccounts::CSendAsAccounts() +: iMessageType(KNullUid), iAccounts(KMessageAccountArrayGranularity) + { + } + +void CSendAsAccounts::ConstructL() + { + iAccountNames = new (ELeave) CDesCArrayFlat(KMessageAccountArrayGranularity); + }