diff -r 000000000000 -r 8e480a14352b messagingfw/sendas/test/sendastestmtm/src/csendastestclientmtm.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/sendas/test/sendastestmtm/src/csendastestclientmtm.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,392 @@ +// 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: +// csendastestclientmtm.cpp +// +#include "csendastestclientmtm.h" + +#include +#include +#include + +#include "csendastestaddress.h" +#include "csendastestsendoperation.h" +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include "msvconsts.h" +#endif + +const TInt KSendAsTestMtmMaxBodySize = 0x100; +const TInt KSendAsTestMtmMaxMessageSize = 0x200; + +EXPORT_C CSendAsTestClientMtm* CSendAsTestClientMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession) + { + CSendAsTestClientMtm* self = new (ELeave) CSendAsTestClientMtm(aRegisteredMtmDll, aSession); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CSendAsTestClientMtm::~CSendAsTestClientMtm() + { + delete iSendAsTestMessage; + } + +CSendAsTestClientMtm::CSendAsTestClientMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession) +: CBaseMtm(aRegisteredMtmDll, aSession) + { + } + +void CSendAsTestClientMtm::ConstructL() + { + // Find the default service... + TMsvSelectionOrdering ordering(KMsvNoGrouping, EMsvSortByNone, ETrue); + CMsvEntry* entry = CMsvEntry::NewL(Session(), KMsvRootIndexEntryId, ordering); + CleanupStack::PushL(entry); + + CMsvEntrySelection* sel = entry->ChildrenWithMtmL(KUidMsgTypeSendAsTest); + CleanupStack::PushL(sel); + if( sel->Count() == 0 ) + { + // There is no service - create it. + TMsvEntry service; + service.iMtm = KUidMsgTypeSendAsTest; + service.iType = KUidMsvServiceEntry; + service.SetReadOnly(EFalse); + service.SetVisible(ETrue); + + entry->SetEntryL(KMsvRootIndexEntryId); + entry->CreateL(service); + + iServiceId = service.Id(); + } + else + { + iServiceId = sel->At(0); + } + CleanupStack::PopAndDestroy(2, entry); // entry, sel + + // Switch the context - this will initialise various objects in the base. + SwitchCurrentEntryL(KMsvRootIndexEntryId); + + iSendAsTestMessage = CSendAsTestMessage::NewL(); + } + +void CSendAsTestClientMtm::DoAddAddresseeL(const TDesC& aAddress, const TDesC& aAlias, CSendAsTestMessage::TSendAsTestAddressType aType) + { + // Need to ensure that the message address list and the addressee list stay + // in sync. First create the address object that will be added to the message + // address list. + CSendAsTestAddress* address = CSendAsTestAddress::NewL(); + CleanupStack::PushL(address); + address->SetAddressL(aAddress); + address->SetAliasL(aAlias); + address->SetAddressType(aType); + + // Add the address info to the addressee list - if this fails then ok as + // message list has not been added to. + AddToAddresseeListL(aAddress, aAlias); + + // Now add to the message address list... + RPointerArray& array = iSendAsTestMessage->Addresses(); + TInt err = array.Append(address); + if( err != KErrNone ) + { + // Could not add address to the message address list - remove the last + // added address from the addressee list. + iAddresseeList->Delete(iAddresseeList->Count()-1); + User::Leave(err); + } + else + { + // The address was successfully added - pop off the cleanup stack. + CleanupStack::Pop(address); + } + } + +void CSendAsTestClientMtm::AddToAddresseeListL(const TDesC& aAddress, const TDesC& aAlias) + { + // Append address to addressee list... + if( aAlias.Length() > 0 ) + { + HBufC* buf = HBufC::NewLC(aAlias.Length() + aAddress.Length() + 3); + TPtr ptr = buf->Des(); + ptr.Copy(aAlias); + ptr.Append(' '); + ptr.Append('<'); + ptr.Append(aAddress); + ptr.Append('>'); + iAddresseeList->AppendL(ptr); + CleanupStack::PopAndDestroy(buf); + } + else + { + iAddresseeList->AppendL(aAddress); + } + } + +void CSendAsTestClientMtm::Reset() + { + // Reset the two address lists. + if( iAddresseeList != NULL ) + { + iAddresseeList->Reset(); + } + if( iSendAsTestMessage != NULL ) + { + iSendAsTestMessage->Addresses().ResetAndDestroy(); + } + } + +/* + * from CBaseMtm + */ + +void CSendAsTestClientMtm::SaveMessageL() + { + __ASSERT_DEBUG( iMsvEntry != NULL, User::Invariant() ); + + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + + switch( iMsvEntry->Entry().iType.iUid ) + { + case KUidMsvServiceEntryValue: + case KUidMsvFolderEntryValue: + break; + case KUidMsvMessageEntryValue: + { + iSendAsTestMessage->StoreL(*store); + StoreBodyL(*store); + TMsvEntry entry(iMsvEntry->Entry()); + if (iSendAsTestMessage->BioType() != KNullUid) + { + entry.iBioType = iSendAsTestMessage->BioType().iUid; + } + + iMsvEntry->ChangeL(entry); + + } break; + default: + User::Invariant(); + } + store->CommitL(); + + // Set the iSize member of the TMsvEntry + if( iMsvEntry->HasStoreL() ) + { + const TInt size = store->SizeL(); + TMsvEntry entry(iMsvEntry->Entry()); + if( entry.iSize != size ) + { + entry.iSize = size; + iMsvEntry->ChangeL(entry); + } + } + CleanupStack::PopAndDestroy(store); + } + +void CSendAsTestClientMtm::LoadMessageL() + { + __ASSERT_DEBUG( iMsvEntry != NULL, User::Invariant() ); + + Reset(); + Body().Reset(); + + CMsvStore* store = iMsvEntry->ReadStoreL(); + CleanupStack::PushL(store); + + switch( iMsvEntry->Entry().iType.iUid ) + { + case KUidMsvServiceEntryValue: + case KUidMsvFolderEntryValue: + break; + case KUidMsvMessageEntryValue: + { + CSendAsTestMessage* message = CSendAsTestMessage::NewL(); + CleanupStack::PushL(message); + + // Restore the message from the store and populate the addressee list. + message->RestoreL(*store); + + const RPointerArray& addresses = message->Addresses(); + TInt count = addresses.Count(); + + for( TInt i=0; iRestoreBodyTextL(Body()); + + CleanupStack::Pop(message); + delete iSendAsTestMessage; + iSendAsTestMessage = message; + } break; + default: + User::Invariant(); + } + CleanupStack::PopAndDestroy(store); + } + +TMsvPartList CSendAsTestClientMtm::ValidateMessage(TMsvPartList /*aPartList*/) + { + TMsvPartList retList = 0; + return retList; + } + +TMsvPartList CSendAsTestClientMtm::Find(const TDesC& /*aTextToFind*/, TMsvPartList /*aPartList*/) + { + TMsvPartList retList = 0; + return retList; + } + +CMsvOperation* CSendAsTestClientMtm::ReplyL(TMsvId /*aDestination*/, TMsvPartList /*aPartlist*/, TRequestStatus& aCompletionStatus) + { + TMsvEntry entry = iMsvEntry->Entry(); + TPckg prog(entry.Id()); + return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeSendAsTest, prog, entry.iServiceId, aCompletionStatus, KErrNotSupported); + } + +CMsvOperation* CSendAsTestClientMtm::ForwardL(TMsvId /*aDestination*/, TMsvPartList /*aPartList*/, TRequestStatus& aCompletionStatus) + { + TMsvEntry entry = iMsvEntry->Entry(); + TPckg prog(entry.Id()); + return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeSendAsTest, prog, entry.iServiceId, aCompletionStatus, KErrNotSupported); + } + +void CSendAsTestClientMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress) + { + DoAddAddresseeL(aRealAddress, KNullDesC(), (CSendAsTestMessage::TSendAsTestAddressType)aType); + } + +void CSendAsTestClientMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress, const TDesC& aAlias) + { + DoAddAddresseeL(aRealAddress, aAlias, (CSendAsTestMessage::TSendAsTestAddressType)aType); + } + +void CSendAsTestClientMtm::AddAddresseeL(const TDesC& aRealAddress) + { + DoAddAddresseeL(aRealAddress, KNullDesC(), CSendAsTestMessage::ESendAsTestAddressTypeTo); + } + +void CSendAsTestClientMtm::AddAddresseeL(const TDesC& aRealAddress, const TDesC& aAlias) + { + DoAddAddresseeL(aRealAddress, aAlias, CSendAsTestMessage::ESendAsTestAddressTypeTo); + } + +void CSendAsTestClientMtm::RemoveAddressee(TInt aIndex) + { + __ASSERT_DEBUG( iSendAsTestMessage->Addresses().Count() == iAddresseeList->Count(), User::Invariant() ); + + // Remove the address from the addressee list and message address list. + iAddresseeList->Delete(aIndex); + iSendAsTestMessage->Addresses().Remove(aIndex); + } + +void CSendAsTestClientMtm::SetSubjectL(const TDesC& aSubject) + { + iSendAsTestMessage->SetSubjectL(aSubject); + } + +void CSendAsTestClientMtm::BioTypeChangedL(TUid aBioTypeUid) + { + iSendAsTestMessage->SetBioTypeL(aBioTypeUid); + } + +TInt CSendAsTestClientMtm::QueryCapability(TUid aCapability, TInt& aResponse) + { + TInt error = KErrNone; + aResponse = ETrue; + switch( aCapability.iUid ) + { + case KUidMtmQueryMaxBodySizeValue: + { + aResponse = KSendAsTestMtmMaxBodySize; + } break; + case KUidMtmQueryMaxTotalMsgSizeValue: + { + aResponse = KSendAsTestMtmMaxMessageSize; + } break; + case KUidMtmQuerySupportedBodyValue: + { + aResponse = KMtm7BitBody + KMtm8BitBody + KMtm16BitBody; + break; + } + case KUidMtmQueryCanSendMsgValue: + case KUidMtmQuerySendAsMessageSendSupportValue: + case KUidMtmQuerySupportAttachmentsValue: + case KUidMtmQuerySupportSubjectValue: + break; + case KUidMtmQueryMaxRecipientCountValue: + { + aResponse = KErrNotFound; // not limited + } break; + case KUidMtmQueryCanReceiveMsgValue: + case KUidMtmQuerySupportsBioMsgValue: + case KUidMtmQuerySupportsSchedulingValue: + case KUidMsvMtmQueryEditorUidValue: + case KUidMtmQueryOffLineAllowedValue: + case KUidMtmQuerySendAsRequiresRenderedImageValue: + case KUidMtmQuerySendAsRenderingUidValue: + case KUidMtmQuerySupportsFolderValue: + case KUidMtmQuerySupportsRecipientTypeValue: + default: + error = KErrNotSupported; + break; + } + return error; + } + +void CSendAsTestClientMtm::InvokeSyncFunctionL(TInt /*FunctionId*/, const CMsvEntrySelection& /*aSelection*/, TDes8& /*aParameter*/) + { + + User::Invariant(); + } + +CMsvOperation* CSendAsTestClientMtm::InvokeAsyncFunctionL(TInt aFunctionId,const CMsvEntrySelection& aSelection, TDes8& aParameter, TRequestStatus& aCompletionStatus) + { + CMsvOperation* op = NULL; + + switch( aFunctionId ) + { + case KMTMStandardFunctionsSendMessage: + { + // perform a regular send with standardised progress information for SendAs2 + op = CSendAsTestSendOperation::NewL(Session(), aSelection, aParameter, aCompletionStatus); + } break; + default: + op = Session().TransferCommandL(aSelection,aFunctionId,(TDesC8&)aParameter, aCompletionStatus); + break; + }; + return op; + } + +TMsvId CSendAsTestClientMtm::DefaultServiceL() const + { + return iServiceId; + } + +void CSendAsTestClientMtm::ContextEntrySwitched() + { + Reset(); + } + +/* + * from MMsvEntryObserver + */ + +void CSendAsTestClientMtm::HandleEntryEvent(TMsvEntryEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) + { + }