diff -r 000000000000 -r 8e480a14352b messagingfw/msgsrvnstore/server/src/MTCLBASE.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/msgsrvnstore/server/src/MTCLBASE.CPP Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,861 @@ +// Copyright (c) 1998-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: +// MTCLBASE.CPP +// +#include +#include +#include +#include + +#include "MSVIDS.H" +#include "MSVAPI.H" +#include "MTCLBASE.H" +#include "MTCLREG.H" +#include "MSVPANIC.H" +#include "MSVUIDS.H" + +#include +#include "CMsvAttachmentWaiter.h" +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include "msvconsts.h" +#endif + +#if defined(_DEBUG) +_LIT(KMtclPanicString, "MSGS"); +#endif + + +EXPORT_C CBaseMtm::CBaseMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession) +: iRegisteredMtmDll(aRegisteredMtmDll), iSession(aSession) +// +// +// +/** Creates a CBaseMtm with member variables initialised from the passed arguments. + + +Client applications do not use this function. It is relevant only to implementers +of derived classes. + +The value of aSession can be accessed through Session(). + +Derived classes can implement a constructor to perform any additional MTM-specific +setup that can be safely carried out in a constructor. Such constructors must +call the base class constructor function. + +Derived classes also implement two-phase construction functions (NewL(), ConstructL()) +to create a new instance of the object, in which any dynamic allocation should +be performed. Client-side MTMs also implement a factory function by which +a MTM registry can request an instance of the class. + +@param aRegisteredMtmDll Registration data for the MTM DLL. +@param aSession The CMsvSession of the client requesting the object */ + {} + + +EXPORT_C CBaseMtm::~CBaseMtm() +// +// +// +/** Cleans up the base class. + +CBaseMtm -derived objects must be deleted by client applications when they +are no longer required. + +Derived classes can implement a destructor to do any additional clean up tasks +that they require. */ + { + DeleteEntry(); + delete iAddresseeList; + delete iRichTextBody; + delete iCharFormatLayer; + delete iParaFormatLayer; + iRegisteredMtmDll.ReleaseLibrary(); + delete iAttachmentWaiter; + delete iExtensionData; + } + + +EXPORT_C TUid CBaseMtm::Type() const +/** Gets the Type UID of the message type associated with the Client-side MTM. + +@return UID of the message type associated with the MTM */ + { + return iRegisteredMtmDll.MtmTypeUid(); + } + + +EXPORT_C TInt CBaseMtm::QueryCapability(TUid /*aCapability*/, TInt& /*aResponse*/) +// +// +// + /** Queries if the MTM supports a particular capability, specified by a UID. + + For MTM-specific UIDs, see the documentation for the relevant MTM. + + Requirements: + + Implementations should check aCapability for the standard capability values, + plus any MTM-specific capabilities, and if recognised, return a suitable response + in aResponse. If aCapability is unknown, return KErrNotSupported. + + The default implementation returns KErrNotSupported. + + @param aCapability UID of capability to be queried + @param aResponse Response value. The format of the response varies according + to the capability. + @return KErrNone: aCapability is a recognised value and a response is returned + KErrNotSupported: aCapability is not a recognised value */ + { + return KErrNotSupported; + } + + + +EXPORT_C void CBaseMtm::SwitchCurrentEntryL(TMsvId aId) +// +// +// +/** Changes the entry on which later actions are performed to the entry with the +specified TMsvId. + +@param aId The ID of the entry upon which all following actions will be performed + +@leave KErrNoMemory Insufficient memory +@leave KErrNotFound The requested entry does not exist */ + { + // create the new CMsvEntry + CMsvEntry* newEntry = Session().GetEntryL(aId); + SetCurrentEntryL(newEntry); + } + + + +EXPORT_C void CBaseMtm::SetCurrentEntryL(CMsvEntry* aEntry) +// +// +// +/** Sets the entry on which later actions are performed to the specified CMsvEntry. + + +@param aEntry The entry on which all following actions will be performed +@leave KErrNoMemory Insufficient memory */ + { + CleanupStack::PushL(aEntry); + + if (iAddresseeList==NULL) + iAddresseeList = CMsvRecipientList::NewL(); + if (iParaFormatLayer==NULL) + iParaFormatLayer = CParaFormatLayer::NewL(); + if (iCharFormatLayer==NULL) + iCharFormatLayer = CCharFormatLayer::NewL(); + if (iRichTextBody==NULL) + iRichTextBody = CRichText::NewL(iParaFormatLayer, iCharFormatLayer); + else + iRichTextBody->Reset(); + + aEntry->AddObserverL(*this); + + CleanupStack::Pop(); // aEntry + + // swap the old and new context + DeleteEntry(); + iMsvEntry = aEntry; + iEntryId = iMsvEntry->EntryId(); + + // If waiting for attachment additons to be commited, delete without commiting + // the changed + delete iAttachmentWaiter; + iAttachmentWaiter = NULL; + + // inform concrete implementation that the context has switched (or set in the first case) + ContextEntrySwitched(); + } + + +EXPORT_C CMsvEntry& CBaseMtm::Entry() const +/** Gets a CMsvEntry for the current context. The message client application can +then use this to manipulate the entry. + +Implementers should note that this function returns the value of the protected +data member iMsvEntry. + +@return CMsvEntry for the current context */ + { + __ASSERT_DEBUG(iMsvEntry!=NULL, User::Panic(KMtclPanicString, 275)); + return *iMsvEntry; + }; + + +EXPORT_C TBool CBaseMtm::HasContext() const +/** Tests if an MTM context has been set. + +A Client-side MTM has no context until one is set through SwitchCurrentEntryL() +or SetCurrentEntryL() . + +@return ETrue: context has been set EFalse: context has not been set */ + { + return (iMsvEntry!=NULL); + } + + +void CBaseMtm::DeleteEntry() +// +// +// + { + if (iMsvEntry!=NULL) + { + iMsvEntry->RemoveObserver(*this); + delete iMsvEntry; + iMsvEntry=NULL; + } + } + +EXPORT_C void CBaseMtm::StoreBodyL(CMsvStore& aStore) +// +// +// +/** Stores and commits the current cached CRichText body text to the appropriate +stream in the specified message store. Client applications do not use this +function. It is relevant only to implementers of derived classes. + +The function overwrites any existing data in that stream. The implementation +must have write access to aStore. + +A typical use of this function is from SaveMessageL(). + +@param aStore Message store in which to store the body text +@leave KErrAccessDenied The store was opened for read only +@leave Other Standard stream-related leave codes */ + { + __ASSERT_ALWAYS(iMsvEntry!=NULL, PanicServer(EMtclMsvEntryNotSet)); + __ASSERT_ALWAYS(iMsvEntry->EntryId()==iEntryId, PanicServer(EMtclContextChangedByOwner)); + + aStore.StoreBodyTextL(*iRichTextBody); + } + +EXPORT_C void CBaseMtm::RestoreBodyL(CMsvStore& aStore) +// +// +// +/** Gets the current cached CRichText from the appropriate stream in the specified +message store. Client applications do not use this function. It is relevant +only to implementers of derived classes. + +A typical use of this function is from LoadMessageL(). + +@param aStore Message store from which to read the body text */ + { + __ASSERT_ALWAYS(iMsvEntry!=NULL, PanicServer(EMtclMsvEntryNotSet)); + __ASSERT_ALWAYS(iMsvEntry->EntryId()==iEntryId, PanicServer(EMtclContextChangedByOwner)); + + aStore.RestoreBodyTextL(*iRichTextBody); + } + + +EXPORT_C CRichText& CBaseMtm::Body() +/** Gets the body text of the context, that must be a message. For non-message +contexts, an empty CRichText is returned. + +@return Body text of the context +@see StoreBodyL() +@see RestoreBodyL() */ + { + __ASSERT_DEBUG(iMsvEntry!=NULL, User::Panic(KMtclPanicString, 275)); + return *iRichTextBody; + } + + +EXPORT_C const CRichText& CBaseMtm::Body() const +/** Gets the read-only body text of the context, that must be a message. For non-message +contexts, an empty CRichText is returned. + +@return Read-only body text of the context +@see StoreBodyL() +@see RestoreBodyL() */ + { + __ASSERT_DEBUG(iMsvEntry!=NULL, User::Panic(KMtclPanicString, 275)); + return *iRichTextBody; + } + + +EXPORT_C void CBaseMtm::SetSubjectL(const TDesC& /*aSubject*/) +// +// +// + /** Sets the subject text of the context, which must be a message. + + Some Client-side MTMs may not support subject text, in which case the function + leaves with KErrNotSupported. + + Requirements: + + If the message protocol supports subject text, implementations should maintain + a private buffer to store this information, settable through this function. + + Implementations should save the subject text to the appropriate place in the + message store when the message is stored. + + The default implementation leaves with KErrNotSupported. + + @param aSubject Message subject text + @leave KErrNotSupported The Client-side MTMs does not support subject text + @see StoreBodyL() + @see RestoreBodyL() */ + { + User::Leave(KErrNotSupported); + } + + +/** Gets the list of intended recipients for the current context, which must be +a message. + +In the case of protocols that allow different classes of recipient (such as +To, Cc and Bcc), the list returned is whatever the protocol defines as the +default recipient list. + +Requirements: + +The default implementation simply returns the value of the protected data +member iAddresseeList. As a consequence, Client-side MTM implementations should +update this member whenever the address list is modified. + +@return Array of recipients +*/ +EXPORT_C const CMsvRecipientList& CBaseMtm::AddresseeList() const + { + __ASSERT_DEBUG(iMsvEntry!=NULL, User::Panic(KMtclPanicString, 275)); + return *iAddresseeList; + } + + +/** Adds addressee to list. + +The default implementation treats To: and Cc: type addressees as if the addressee +had no type. + +The default implementation does not support Bcc type addressees. + +@param aType +The addressee type. + +@param aRealAddress +The addressee address. + +@leave KErrNotSupprted +The addressee type was Bcc which is not supported in the default implementation. +*/ +EXPORT_C void CBaseMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress) + { + if (aType == EMsvRecipientBcc) + { + User::Leave(KErrNotSupported); + } + AddAddresseeL(aRealAddress); + } + + +/** Adds addressee to list. + +The default implementation treats To: and Cc: type addressees as if the addressee +had no type. + +The default implementation does not support Bcc type addressees. + +@param aType +The addressee type. + +@param aRealAddress +The addressee address. + +@param aAlias +The alias for the addressee. + +@leave KErrNotSupprted +The addressee type was Bcc which is not supported in the default implementation. +*/ +EXPORT_C void CBaseMtm::AddAddresseeL(TMsvRecipientType aType, const TDesC& aRealAddress, const TDesC& aAlias) + { + if (aType == EMsvRecipientBcc) + { + User::Leave(KErrNotSupported); + } + AddAddresseeL(aRealAddress, aAlias); + } + + +EXPORT_C const TPtrC CBaseMtm::SubjectL() const +// +// +// +/** Gets the subject text of the context, which must be a message. + +Some Client-side MTMs may not support subject text, in which case the function +leaves with KErrNotSupported. + +Requirements: + +If the message protocol supports subject text, implementations should maintain +a private buffer to store this information, gettable through this function. + +The default implementation leaves with KErrNotSupported. + +@leave KErrNotSupported The Client-side MTMs does not support subject text +@return Message subject text */ + { + User::Leave(KErrNotSupported); + return TPtrC(); + } + + +EXPORT_C void CBaseMtm::HandleEntryEventL(TMsvEntryEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) +/** Indicates that an event has occurred. + +Client applications do not use this function. It is relevant only to implementers of derived classes. + +The Client-side MTM object is automatically set as an observer, through CMsvEntry::AddObserverL(), +for the context whenever the context changes (by SetCurrentEntryL() or SwitchCurrentEntryL()). + +The default implementation is defined to do nothing. + +Requirements: + +Implementations can override this function to handle events concerning the current context. + +@param aEvent Indicates the event type +@param aArg1 Event specific argument value +@param aArg2 Event specific argument value +@param aArg3 Event specific argument value +*/ + { + } + + +EXPORT_C CMsvSession& CBaseMtm::Session() +/** Gets a reference to the session object passed by the creator of the Client-side +MTM. + +@return Session object used by the Client-side MTM */ + { + return iSession; + } + + +/** +Adds a file attachment to the current message entry. + +The attachment is referenced by its file path and is copied into the message store. +Only one asynchronous operation can be run at any one time. + +@param aFilePath The full path specification of the attachment file. +@param aMimeType The mime type of the attachment file. +@param aCharset The mime charset. The value is a standard IANA value. The value 0 indicates + that no charset is provided. +@param aStatus The request status to complete when request has completed. +@leave System-wide error codes. +*/ +EXPORT_C void CBaseMtm::AddAttachmentL(const TDesC& aFilePath, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus) + { + AddFilePathAttachmentL(aFilePath, aMimeType, aCharset, CMsvAttachment::EMsvFile, aStatus); + } + +/** +Adds a file attachment to the current message entry. + +The attachment is referenced by an open file handle and is copied into the message store. +Only one asynchronous operation can be run at any one time. + +@param aFile An open file handle for the file attachment. +@param aMimeType The mime type of the attachment file. +@param aCharset The mime charset. The value is a standard IANA value. The value 0 indicates + that no charset is provided. +@param aStatus The request status to complete when request has completed. +@leave System-wide error codes. +*/ +EXPORT_C void CBaseMtm::AddAttachmentL(RFile& aFile, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus) + { + if( iAttachmentWaiter == NULL ) + iAttachmentWaiter = CMsvAttachmentWaiter::NewL(); + + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + + CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); + CleanupStack::PushL(attachment); + + // set the size + TInt size = 0; + User::LeaveIfError(aFile.Size(size)); + attachment->SetSize(size); + + // set the mime-type if provided + if( aMimeType.Length() > 0 ) + { + attachment->SetMimeTypeL(aMimeType); + } + + TFileName fileName; + User::LeaveIfError(aFile.Name(fileName)); + attachment->SetAttachmentNameL(fileName); + + if( aCharset!=0 ) + { + CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC(); + headers->SetMimeCharset(aCharset); + headers->StoreL(*attachment); + CleanupStack::PopAndDestroy(headers); + } + + // attachment is initialised, pass to the attachment manager + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + manager.AddAttachmentL(aFile, attachment, iAttachmentWaiter->iStatus); + CleanupStack::Pop(attachment); // ownership passed to manager + iAttachmentWaiter->StartWaitingL(aStatus, store, &manager); + CleanupStack::Pop(store); // ownership passed + } + +/** +Adds a file attachment to the current message entry as a linked file. + +The attachment is referenced by its file path and is not copied into the message store. The attachment file is always used from +its original location on disk indicated by the aFilePath parameter. Only one asynchronous operation can be run at any one time. + +@param aFilePath The full path specification of the attachment file. +@param aMimeType The mime type of the attachment file. +@param aCharset The mime charset. The value is a standard IANA value. The value 0 indicates + that no charset is provided. +@param aStatus The request status to complete when request has completed. +@leave System-wide error codes. +*/ +EXPORT_C void CBaseMtm::AddLinkedAttachmentL(const TDesC& aFilePath, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus) + { + AddFilePathAttachmentL(aFilePath, aMimeType, aCharset, CMsvAttachment::EMsvLinkedFile, aStatus); + } + +/** +Creates a new empty file attachment to the current message entry. + +An empty file attachment is created with the suggested given name and if +completed successfully, the aAttachmentFile will be open on the new file. +Only one asynchronous operation can be run at any one time. + +@param aFileName The suggested file name for the new attachment file. +@param aAttachmentFile If successful, this will be set to the open new file. +@param aMimeType The mime type of the attachment file. +@param aCharset The mime charset. The value is a standard IANA value. The value 0 indicates + that no charset is provided. +@param aStatus The request status to complete when request has completed. +@leave System-wide error codes. +*/ +EXPORT_C void CBaseMtm::CreateAttachmentL(const TDesC& aFileName, RFile& aAttachmentFile, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus) + { + if( iAttachmentWaiter == NULL ) + iAttachmentWaiter = CMsvAttachmentWaiter::NewL(); + + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + + CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); + CleanupStack::PushL(attachmentInfo); + attachmentInfo->SetAttachmentNameL(aFileName); + attachmentInfo->SetMimeTypeL(aMimeType); + + if( aCharset!=0 ) + { + CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC(); + headers->SetMimeCharset(aCharset); + headers->StoreL(*attachmentInfo); + CleanupStack::PopAndDestroy(headers); + } + + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + manager.CreateAttachmentL(aFileName, aAttachmentFile, attachmentInfo, iAttachmentWaiter->iStatus); + CleanupStack::Pop(attachmentInfo); // ownership passed to manager + iAttachmentWaiter->StartWaitingL(aStatus, store, &manager); + CleanupStack::Pop(store); // ownership passed + } + +/** +Adds a message entry as an attachment to the current message entry. + +This method simply registers an existing message entry as an attachment to the current entry. Only one asynchronous +operation can be run at any one time. + +@param aAttachmentId The message Id of the message entry to add as an attachment. +@param aStatus The request status to complete when request has completed. +@leave System-wide error codes. +*/ +EXPORT_C void CBaseMtm::AddEntryAsAttachmentL(TMsvId aAttachmentId, TRequestStatus& aStatus) + { + // Get the size of the message entry + CMsvEntry* attachEntry = iSession.GetEntryL(aAttachmentId); + TInt attachSize = attachEntry->Entry().iSize; + delete attachEntry; + attachEntry = NULL; + + if( iAttachmentWaiter == NULL ) + iAttachmentWaiter = CMsvAttachmentWaiter::NewL(); + + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + + CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvMessageEntry); + CleanupStack::PushL(attachment); + attachment->SetSize(attachSize); + + // Register entry as attachment + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + manager.AddEntryAsAttachmentL(aAttachmentId, attachment, iAttachmentWaiter->iStatus); + CleanupStack::Pop(attachment); // ownership passed to manager + iAttachmentWaiter->StartWaitingL(aStatus, store, &manager); + CleanupStack::Pop(store); // ownership passed + } + +void CBaseMtm::AddFilePathAttachmentL(const TDesC& aFilePath, const TDesC8& aMimeType, TUint aCharset, CMsvAttachment::TMsvAttachmentType aType, TRequestStatus& aStatus) + { + __ASSERT_DEBUG(aType != CMsvAttachment::EMsvMessageEntry, User::Invariant()); + + if( iAttachmentWaiter == NULL ) + iAttachmentWaiter = CMsvAttachmentWaiter::NewL(); + + CMsvStore* store = iMsvEntry->EditStoreL(); + CleanupStack::PushL(store); + + CMsvAttachment* attachment = CMsvAttachment::NewL(aType); + CleanupStack::PushL(attachment); + + // set the size + TEntry fileEntry; + RFs& fs = iSession.FileSession(); + User::LeaveIfError(fs.Entry(aFilePath, fileEntry)); + attachment->SetSize(fileEntry.iSize); + + // set the mime-type, if provided + if( aMimeType.Length() > 0 ) + { + attachment->SetMimeTypeL(aMimeType); + } + + // set attachment name + TParse fileNameParser; + User::LeaveIfError(fileNameParser.Set(aFilePath, NULL, NULL)); + attachment->SetAttachmentNameL(fileNameParser.NameAndExt()); + + if( aCharset!=0 ) + { + CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC(); + headers->SetMimeCharset(aCharset); + headers->StoreL(*attachment); + CleanupStack::PopAndDestroy(headers); + } + + // attachment is initialised, pass to the attachment manager + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + switch(aType) + { + case CMsvAttachment::EMsvFile: + manager.AddAttachmentL(aFilePath, attachment, iAttachmentWaiter->iStatus); + break; + case CMsvAttachment::EMsvLinkedFile: + manager.AddLinkedAttachmentL(aFilePath, attachment, iAttachmentWaiter->iStatus); + break; + default: + break; + } + + CleanupStack::Pop(attachment); // ownership passed to manager + + iAttachmentWaiter->StartWaitingL(aStatus, store, &manager); + CleanupStack::Pop(store); // ownership passed + } + +/** +Cancels the current attachment operation. +*/ +EXPORT_C void CBaseMtm::CancelAttachmentOperation() + { + __ASSERT_ALWAYS(iAttachmentWaiter != NULL, PanicServer(EMsvOperationNotFound)); + iAttachmentWaiter->Cancel(); + delete iAttachmentWaiter; + iAttachmentWaiter = NULL; + } + + +// virtual +EXPORT_C void CBaseMtm::CreateMessageL(TMsvId aServiceId) +/** Creates a new message entry as a child of the current context. + +The default implementation creates an empty entry with its visible flag set +to false and its in-preparation flag set to true. + +@param aServiceId ID of the service to own the entry. */ + { + // create an invisible blank entry + TMsvEntry entry; + entry.iType = KUidMsvMessageEntry; + entry.iServiceId = aServiceId; + entry.iMtm = Type(); + entry.SetVisible(EFalse); + entry.SetInPreparation(ETrue); + + // store entry in folder + iMsvEntry->CreateL(entry); + iMsvEntry->SetEntryL(entry.Id()); + iEntryId = entry.Id(); + } + +EXPORT_C void CBaseMtm::BioTypeChangedL(TUid /*aBioTypeUid*/) + /** Informs client-side MTM that the context's BIO field is being changed as a + result of a call to CSendAs::SetBioTypeL(). + + CSendAs::SetBioTypeL() calls this function before setting the BIO field in + the context's index entry. This allows a client-side MTM to perform MTM specific + actions when the BIO type changes. + + CSendAs will not change the BIO type if this function leaves. + + The default implementation is to do nothing. + + @param aBioTypeUid New value for the BIO field + @see CSendAs::SetBioTypeL() */ + { + //The default implementation is to do nothing. + } + +/** +Gets the default MTM service. + +The default implementation is to assume the MTM only supports one service so finds the +first service associated with this MTM and returns that. + +@return +The default service + +@leave +KErrNotFound If no service has been created. +*/ +EXPORT_C TMsvId CBaseMtm::DefaultServiceL() const + { + // Create a new entry, showing invisible entries (because the service entry may be invisible) + TMsvSelectionOrdering ordering(KMsvNoGrouping, EMsvSortByNone, ETrue); + CMsvEntry* entry = CMsvEntry::NewL(iSession, KMsvRootIndexEntryId, ordering); + CleanupStack::PushL(entry); + + CMsvEntrySelection *sel=entry->ChildrenWithMtmL(iRegisteredMtmDll.MtmTypeUid()); + CleanupStack::PushL(sel); + if(sel->Count() == 0) + { + User::Leave(KErrNotFound); + } + TMsvId service=sel->At(0); + CleanupStack::PopAndDestroy(2,entry); + return service; + } + +/** +Removes the default service setting. The default implementation of this function assumes +that the MTM only supports one service and therefore this does nothing. +*/ +EXPORT_C void CBaseMtm::RemoveDefaultServiceL() + { + } + +/** +Sets the default MTM service. The default implementation of this function assumes that +the MTM only supports one service and therefore this does nothing. + +@param aService +The default service +*/ +EXPORT_C void CBaseMtm::ChangeDefaultServiceL(const TMsvId& /*aService*/) + { + } + + +/** +Returns a pointer to the interface with the specified Uid. + +This method is the first part of an extension pattern to allow for +more functionality to be supported without adding virtual methods +to this base class. + +The default implementation returns a NULL pointer. + +@param aUid +Uid of the extension interface +@return +Pointer to the extension interface +*/ +EXPORT_C TAny* CBaseMtm::GetInterface(TUid /*aUid*/) + { + return NULL; + } + +/** +Sets the character encoding value. The character encoding value options are 7-bit, +8-bit and 16-Bit Unicode. By default the character set encoding is 7 bit encoding. +@param aCharSet Character encoding value may be 7-bit/8-bit/16-bit Unicode. +@return KErrNone If charset is changed successfully in SMS settings. +*/ + +EXPORT_C TInt CBaseMtm::SetMessageCharacterSet(TUint aCharSet) + { + TAny* ptrNull=NULL; + return Extension_(KUIDCharacterSet,ptrNull,&aCharSet); + } + +/** +The default Extension service. The default implementation of this function assumes that +the new service for setting the charset encoding value for a SMS message is not +supported. TAny* is equivalent to void*. +@param a0 The collective parameters of TAny* +@param a1 The collective parameters of TAny*,Charset encoding value is actually extracted from a1. +@param aExtensionId Uid of the extension interface +@return KErrExtensionNotSupported If the message is other than SMS. +@return Other Standard system-wide error codes. +*/ + +EXPORT_C TInt CBaseMtm::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1) + { + TInt ret = KErrNone; + switch(aExtensionId) + { + case KUIDCharacterSet: + { + ret = KErrExtensionNotSupported; + } + break; + default: + { + // Chain to base class + ret = CBase::Extension_(aExtensionId,a0,a1); + } + break; + } + return ret; + } + +//if passed value is NULL, its as good as reset extention data +EXPORT_C void CBaseMtm::SetExtensionData(TAny* aSortData) + { + iExtensionData=aSortData; + } + +EXPORT_C TAny* CBaseMtm::GetExtensionData() + { + return iExtensionData; + } +