diff -r 000000000000 -r 72b543305e3a messagingappbase/obexmtms/obexmtm/obexclient/source/obexClientMtm.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/obexmtms/obexmtm/obexclient/source/obexClientMtm.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,443 @@ +// Copyright (c) 2001-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: +// + +//class include +#include + +//system includes +#include +#include +#include // CRichText + +#include // KUidMtmQueryCanSendMsg +#include // CRegisteredMtmDll +#include // KUidMtmQueryxxx & TMsvPartList flags +#include // KUidMsvMessageEntry +#include // CObexMtmHeader + + +#include +#include + + +#include + +//user includes +#include "obexClientMtmPanic.h" + + +const TInt KMaxObexPasswordLength = 30; + +// +// CObexClientMtm +// +EXPORT_C CObexClientMtm::CObexClientMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aMsvSession, TUid aMsgTypeUid) +: CBaseMtm(aRegisteredMtmDll, aMsvSession), +iMsgTypeUid(aMsgTypeUid) +/** + * Constructor. Initialises iMsgTypeUid with Uid provided by the derived class. + * + * @param aRegisteredMtmDll Registration data for MTM DLL. + * @param aMsvSession CMsvSession of the client requesting the object. + * @param aMsgTypeUid Uid of the message + */ + { + } + +EXPORT_C void CObexClientMtm::ConstructL() +/** + * Empty implementation provided for future-proofing. + */ + { + } + +EXPORT_C CObexClientMtm::~CObexClientMtm() +/** + * Destructor deletes FileNameExternaliser and Header + */ + { + delete iHeader; + } + +EXPORT_C void CObexClientMtm::SaveMessageL() +/** + * Commits cached changes to the message store, by calling CommitChangesL. + * + * @leave KErrXxx System-wide error codes if message cannot be saved. + */ + { + //Commit header to store. + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + iHeader->StoreL(*store); + store->CommitL(); + CleanupStack::PopAndDestroy(); + + CommitChangesL(); + + } + +EXPORT_C void CObexClientMtm::CommitChangesL() +/** + * Commits cached changes to the message store. + * + * @leave KErrXxx System-wide error codes if changes cannot be committed. + */ + { // OBEX messages are very simple. Outgoing data is expected to be in attachments. To save space filenames + // can be stored within entry (instead of making copies of the data), which will be loaded upon send. + if(Body().DocumentLength() > 0) + { + User::Leave(KErrNotSupported); // Data is not expected in the message body + } + + // Update entry details + TMsvEntry messageEntry=iMsvEntry->Entry(); + + // since CBaseMtm::CreateMessageL creates message as in preparation and non-visible, + // must now make it visible and not in preparation + messageEntry.SetVisible(ETrue); + messageEntry.SetInPreparation(EFalse); + + messageEntry.iSize = GetAttachmentSizeL(); + messageEntry.iDescription.Set(SubjectL()); + + if (AddresseeList().Count() > 0) + messageEntry.iDetails.Set(AddresseeList()[0]); + + // Display the required send status. + messageEntry.SetSendingState(KMsvSendStateWaiting); // Quartz are checking this flag for ir messaging for sending + + // update the contents of the message entry + iMsvEntry->ChangeL(messageEntry); + } + + + +EXPORT_C void CObexClientMtm::CreateMessageL(TMsvId /*aServiceId*/) +/** + * Create a new message for this MTM. This creates a new messaging entry, then + * re-initialises the MTM's CObexMtmHeader object. + * + * @param aServiceId The ID of the service for which the message is to be created + * @leave KErrXxx Standard EPOC error codes if construction of new objects fails + */ + { + // First create the message as normal: this creates a new entry of the current MTM type + CBaseMtm::CreateMessageL(KMsvRootIndexEntryId); + + // Now call ContextEntrySwitched as this isn't called from CBaseMtm::CreateMessageL + ContextEntrySwitched(); + + // Now create a new iHeader + InitialiseHeaderL(); + } + + +EXPORT_C void CObexClientMtm::LoadMessageL() +/** + * This function loads the header from the message store + * + * @leave KErrXXX system-wide error codes + */ + { + __ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EObexMtmNoCMsvEntrySet)); + __ASSERT_DEBUG(iMsvEntry->Entry().iType.iUid==KUidMsvMessageEntryValue, gPanic(EObexMtmNotAMessageEntry)); + + //(Re-)initialise header to appropriate CObexMtmHeader derived class + InitialiseHeaderL(); + + + // INC042015: + // catch and "pre-process" here errors in ReadStoreL. + // Ignore the error if the leave occurs because there is no store, UNLESS the message + // is being sent (in this case the header IS needed). + CMsvStore* store = NULL; + TRAPD(err, store = iMsvEntry->ReadStoreL() ); + if (err == KErrNone) // store is OK + { + CleanupStack::PushL(store); + iHeader->RestoreL(*store); + CleanupStack::PopAndDestroy(); + } + else if ( (err == KErrNotFound) && (iMsvEntry->Entry().Parent() != KMsvGlobalOutBoxIndexEntryId) ) + { // ignore error in this particular case: the header is not needed. + return; + } + else // in all other cases, pass on the error as was done before + { + User::LeaveIfError(err); + } + } + + +EXPORT_C TInt32 CObexClientMtm::GetAttachmentSizeL() +/** + * This function calculates the size of all attachments to the message by either: + * + * @li summing the sizes of each of the children or; + * @li reading in all of the filenames from the store, and summing their sizes.* + * + * @return total size of the attachments. + * @leave KErrXXX system-wide error codes + */ + { + TInt size=0; //Total attachment size + + + + // size has not yet been set, must be using the Attachment API, so use + // the Attachment API to calculate size + CMsvStore* store = iMsvEntry->ReadStoreL(); + CleanupStack::PushL(store); + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + TInt attachmentCount = manager.AttachmentCount(); + for( TInt ii=0; iiType() == CMsvAttachment::EMsvMessageEntry ) + { + // Only EFileAttachment and ELinkedFile are supported + User::Leave(KErrArgument); + } + size += attachmentInfo->Size(); + delete attachmentInfo; + } + CleanupStack::PopAndDestroy(store); + + + return size; + } + +// + +EXPORT_C CMsvOperation* CObexClientMtm::ReplyL(TMsvId /*aReplyEntryId*/, TMsvPartList /*aPartlist*/, TRequestStatus& /*aCompletionStatus*/) +/** + * Unsupported + * + * @leave Leaves always with KErrNotSupported + */ + { + User::Leave(KErrNotSupported); + return (CMsvOperation*)NULL; + } + +EXPORT_C CMsvOperation* CObexClientMtm::ForwardL(TMsvId /*aForwardEntryId*/, TMsvPartList /*aPartList*/, TRequestStatus& /*aCompletionStatus*/) +/** + * Unsupported + * + * @leave Leaves always with KErrNotSupported + */ + { + User::Leave(KErrNotSupported); + return (CMsvOperation*)NULL; + } + +EXPORT_C TUint CObexClientMtm::ValidateMessage(TMsvPartList aPartList) +/** + * Ensure that the current message context part indicated is valid. Currently only works on KMsvMessagePartRecipient--all other parts + * are assumed to be valid + * + * @param aPartList Bitmask indicating parts of message to be validated + * @return Bitmask of any invalid parts--KErrNone otherwise + */ + { + TMsvPartList failed = KErrNone; // No errors. + + if (!iAddresseeList) + { + return KMsvMessagePartRecipient; + } + + if(aPartList & KMsvMessagePartRecipient) + { + // All actual recipients should have at least one character. + for (TInt ii=0; ii < iAddresseeList->Count(); ++ii) + { + if((*iAddresseeList)[ii].Length() == 0) + { + failed |= KMsvMessagePartRecipient; + break; + } + } + } + return failed; + } + + +EXPORT_C TMsvPartList CObexClientMtm::Find(const TDesC& /*aTextToFind*/, TMsvPartList /*aPartList*/) +/** + * Finds the given text within the specified parts of the current message context. NOT IMPLEMENTED! + * + * @param aTextToFind Reference to the text to search for in the specified message parts + * @param aPartList Bitmask indicating parts of message to be searched for the text + * @return Bitmask of any parts containing the message text + */ + { + return 0; + } + + +EXPORT_C void CObexClientMtm::SetSubjectL(const TDesC& aSubject) +/** + * Sets the subject of the current message context + * + * @param aSubject Reference to the new message subject text + * @leave Leaves if creation of new HBufC fails + */ + { + iHeader->SetSubjectL(aSubject); + } + + +EXPORT_C const TPtrC CObexClientMtm::SubjectL() const +/** + * Returns the subject of the current message context. Will not leave. + * + * @return const TPtrC representation of the Subject, or an empty TPtrC if the subject hasn't been set + * @leave Never + */ + { + return iHeader->Subject(); + } + + +EXPORT_C void CObexClientMtm::AddAddresseeL(const TDesC& aRealAddress) +/** + * Adds addressee to the addressee "list". Note that this MUST be a TDesC containing binary data representing + * the TSockAddress of the addressee, usually as a TDesC16. This function will then package the data directly into + * 8 bit data. + * NB: Only ONE addressee is supported + * + * @param aRealAddress Reference to the address of the recipient + * @leave KErrXXX if address cannot be appended + * @leave KErrAlreadyExists if the Addressee "list" already contains an entry + */ + { + if (iAddresseeList->Count()==0) + { + //list is empty--OK to add addressee + iAddresseeList->AppendL(aRealAddress); + + } + else + { + //list already contains an entry--leave with KErrAlreadyExists + User::Leave(KErrAlreadyExists); + } + } + +EXPORT_C void CObexClientMtm::AddAddresseeL(const TDesC& aRealAddress, const TDesC& /*aAlias*/) + +/** + * Adds addressee to the addressee "list". Note that this MUST be a TDesC containing binary data representing + * the TSockAddress of the addressee, usually as a TDesC16. This function will then package the data directly into + * 8 bit data. + * NB: Only ONE addressee is supported + * + * @param aRealAddress Reference to the address of the recipient + * @param aAlias Reference to the alias of the recipient--ignored in this implementation + * @leave KErrXXX if address cannot be appended + * @leave KErrAlreadyExists if the Addressee "list" already contains an entry + */ + { + AddAddresseeL(aRealAddress); + } + +EXPORT_C void CObexClientMtm::RemoveAddressee(TInt /*aIndex*/) +/** + * Removes addressee at index aIndex from the addressee "list". + * + * @param aIndex zero-based index of the addressee (ignored since "there can be only one"). + */ + { + if (iAddresseeList->Count() > 0) //since only one addressee is supported anyhow + { + iAddresseeList->Delete(0); + } + } + +EXPORT_C void CObexClientMtm::ContextEntrySwitched() +/** + * Resets the MTM when the context is switched. + * Must be called by the derived class's ContextEntrySwitched prior to constructing a new header. + */ + { + iAddresseeList->Reset(); + delete iHeader; //will be reconstructed in LoadMessageL() + iHeader = NULL; + } + + +EXPORT_C TInt CObexClientMtm::QueryCapability(TUid aCapability, TInt& aResponse) +/** + * Gives the capability of the MTM. + * + * @param aCapability capability to be queried + * @param aResponse capability dependent return value. + * @return KErrNone if the capability is supported, or KErrNotSupported if not. + */ + { + TInt error = KErrNone; + switch (aCapability.iUid) + { + case KUidMtmQueryMaxBodySizeValue: + case KUidMtmQueryMaxTotalMsgSizeValue: + aResponse = KMaxTInt; + break; + case KUidMtmQuerySupportAttachmentsValue: + case KUidMtmQuerySupportSubjectValue: + case KUidMtmQueryCanSendMsgValue: + case KUidMtmQuerySupportsBioMsgValue: + case KUidMtmQuerySendAsMessageSendSupportValue: + break; + case KUidMtmQueryMaxRecipientCountValue: + aResponse = 1; + break; + case KUidMtmQuerySupportedBodyValue: + aResponse = KMtm7BitBody + KMtm8BitBody + KMtm16BitBody + KMtmBinaryBody; + break; + case KUidMsvMtmQueryEditorUidValue: // Return NULL for editor value because there is no OBEX editor. + break; + default: + return KErrNotSupported; + } + return error; + } + +/** +Obex based MTMs do not support message entry attachments. This method will leave with +KErrNotSupported. +@param aAttachmentId This is not supported. +@leave KErrNotSupported This method is not supported. +*/ +EXPORT_C void CObexClientMtm::CreateMessageAttachmentL(TMsvId /*aAttachmentId*/) + { + User::Leave(KErrNotSupported); + } + +/** +No functionality is provided by this method. Leaves with KErrNotSupported. +@param aFunctionId Unused. +@param aSelection Unused. +@param aParameter Unused. +@leave KErrNotSupported +*/ +EXPORT_C void CObexClientMtm::InvokeSyncFunctionL(TInt /*aFunctionId*/, const CMsvEntrySelection& /*aSelection*/, TDes8& /*aParameter*/) + { + User::Leave(KErrNotSupported); + } + +