--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/utilityapps/creator/engine/src/creator_message.cpp Mon Oct 18 16:30:05 2010 +0300
@@ -0,0 +1,1825 @@
+/*
+* Copyright (c) 2010 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 "engine.h"
+#include "enginewrapper.h"
+
+#include "creator_message.h"
+#include "creator_traces.h"
+#include "creator_contactsetcache.h"
+#include "creator_phonebook.h"
+#include <apgcli.h>
+#include <MuiuServiceUtilities.h>
+#include <utf.h>
+
+#include <mmf/common/mmfcontrollerpluginresolver.h> // for CleanupResetAndDestroyPushL
+
+//static const TInt KMessagesFieldLength = 1024;
+
+//_LIT(KCreatorMessagesPrefixName, "CR_");
+//_LIT(KCreatorMessagesPrefixFolderName, "CR_FLDR_");
+
+
+const TUid KUidBIOBusinessCardMsg = {0x10005531};
+_LIT(KEmpty, "");
+
+//----------------------------------------------------------------------------
+
+CMessagesParameters::CMessagesParameters()
+ {
+ LOGSTRING("Creator: CMessagesParameters::CMessagesParameters");
+
+ iSenderAddress = HBufC::New(128);
+ iRecipientAddress = HBufC::New(128);
+ iMessageSubject = HBufC::New(128);
+ iMessageBodyText = HBufC::New(10240);
+ TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));
+ iCreateAsUnread = ETrue;
+ }
+
+CMessagesParameters::~CMessagesParameters()
+ {
+ LOGSTRING("Creator: CMessagesParameters::~CMessagesParameters");
+
+
+ delete iMessageBodyText;
+ delete iMessageSubject;
+ delete iRecipientAddress;
+ delete iSenderAddress;
+ delete iAttachments;
+ iAttachmentPaths.ResetAndDestroy();
+ iAttachmentPaths.Close();
+ iRecipientAddressArray.ResetAndDestroy();
+ iRecipientAddressArray.Close();
+ iRecipientLinkIds.Close();
+ iSenderLinkIds.Close();
+ }
+
+//----------------------------------------------------------------------------
+
+CCreatorMessages* CCreatorMessages::NewL(CCreatorEngine* aEngine)
+ {
+ CCreatorMessages* self = CCreatorMessages::NewLC(aEngine);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CCreatorMessages* CCreatorMessages::NewLC(CCreatorEngine* aEngine)
+ {
+ CCreatorMessages* self = new (ELeave) CCreatorMessages;
+ CleanupStack::PushL(self);
+ self->ConstructL(aEngine);
+ return self;
+ }
+
+CCreatorMessages::CCreatorMessages()
+ {
+ }
+
+void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)
+ {
+ LOGSTRING("Creator: CCreatorMessages::ConstructL");
+ iEngine = aEngine;
+
+ TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));
+ iWaiter = CAsyncWaiter::NewL();
+ }
+
+CCreatorMessages::~CCreatorMessages()
+ {
+ LOGSTRING("Creator: CCreatorMessages::~CCreatorMessages");
+
+ if ( iEngine && iEntryIds.Count() )
+ {
+ TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidMessages ) );
+ }
+ iEntryIds.Reset();
+ iEntryIds.Close();
+
+ delete iParameters;
+ delete iWaiter;
+ delete iTmpPhoneNumber;
+ delete iTmpEmail;
+ delete iAttachments;
+
+ iRecipientArray.ResetAndDestroy();
+ iRecipientArray.Close();
+ iSenderArray.ResetAndDestroy();
+ iSenderArray.Close();
+ }
+
+//----------------------------------------------------------------------------
+
+void CCreatorMessages::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)
+ {
+ LOGSTRING("Creator: CCreatorMessages::QueryDialogClosedL");
+
+ if( aPositiveAction == EFalse )
+ {
+ iEngine->ShutDownEnginesL();
+ return;
+ }
+
+ const TDesC* showText = &KSavingText;
+ TBool finished(EFalse);
+ TBool retval(ETrue);
+ switch(aUserData)
+ {
+ case ECreatorMessagesDelete:
+ showText = &KDeletingText;
+ iEntriesToBeCreated = 1;
+ finished = ETrue;
+ break;
+ case ECreatorMessagesStart:
+ // message type query
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message type"), R_MESSAGE_TYPE_QUERY, (TInt*) &iMessageType, this, ECreatorMessagesMessageType);
+ break;
+ case ECreatorMessagesMessageType:
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Folder type"), R_FOLDER_TYPE_QUERY, (TInt*) &iFolderType, this, ECreatorMessagesFolderType);
+ break;
+ case ECreatorMessagesFolderType:
+ // query create as unread
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message status"), R_UNREAD_QUERY, (TInt*)&iCreateAsUnread, this, ECreatorMessagesMessageStatus);
+ break;
+ case ECreatorMessagesMessageStatus:
+ if( iMessageType == ESMS || iMessageType == EMMS || iMessageType == EEmail )
+ {
+ iDefinedMessageLength = 100;
+ retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iDefinedMessageLength, _L("Amount of characters in message body?"), ETrue,
+ this, ECreatorMessagesCharsInBody
+ );
+ break;
+ }
+ else
+ {
+ iDefinedMessageLength = 0;
+ // goto query attachments ... :-) DO NOT break;
+ }
+ case ECreatorMessagesCharsInBody:
+ // query attachments
+ iAttachments->Reset();
+ if( iMessageType == EMMS || iMessageType == EEmail)
+ {
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_MULTI_SELECTION_QUERY,
+ iAttachments, this, ECreatorMessagesAttachment
+ );
+ }
+ else if( iMessageType == EAMS )
+ {
+ iAttachments->AppendL( TInt(0) );
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY,
+ &iAttachments->At(0), this, ECreatorMessagesAttachment
+ );
+ }
+ else if( iMessageType == EIrMessage || iMessageType == EBTMessage )
+ {
+ iAttachments->AppendL( TInt(0) );
+ retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_SINGLE_SELECTION_QUERY,
+ &iAttachments->At(0), this, ECreatorMessagesAttachment
+ );
+ }
+ else
+ {
+ finished = ETrue;
+ }
+ break;
+ case ECreatorMessagesAttachment:
+ finished = ETrue;
+ if(iMessageType== EMMS || iMessageType == EEmail)
+ {
+ // "none" is selected
+ if (iAttachments->At(0) == 0)
+ {
+ iAttachments->Reset();
+ }
+ else // otherwise fix indexes
+ {
+ for (TInt i=0; i<iAttachments->Count(); i++)
+ iAttachments->At(i)--; // decrease value by one
+
+ }
+ }
+ break;
+ default:
+ //some error
+ retval = EFalse;
+ break;
+ }
+ if( retval == EFalse )
+ {
+ iEngine->ShutDownEnginesL();
+ }
+ else if( finished )
+ {
+ // add this command to command array
+ iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);
+ // started exucuting commands
+ iEngine->ExecuteFirstCommandL( *showText );
+ }
+ }
+//----------------------------------------------------------------------------
+
+TBool CCreatorMessages::AskDataFromUserL(TInt aCommand)
+ {
+ LOGSTRING("Creator: CCreatorMessages::AskDataFromUserL");
+
+ CCreatorModuleBase::AskDataFromUserL(aCommand);
+
+ if ( aCommand == ECmdDeleteMessages )
+ {
+ return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages?"), this, ECreatorMessagesDelete );
+ }
+ else if ( aCommand == ECmdDeleteCreatorMessages )
+ {
+ return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages created with Creator?"), this, ECreatorMessagesDelete );
+ }
+
+ return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorMessagesStart );
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)
+ {
+ LOGSTRING2("Creator: CCreatorMessages::CreateRandomMessageEntryL - Command: %d", aCommand);
+
+ TInt err = KErrNone;
+
+ iDefinedMessageLength = iEngine->RandomNumber(100, 300);
+
+
+ switch (aCommand)
+ {
+ case ECmdCreateRandomEntrySMSInbox: { iMessageType=ESMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntrySMSDrafts: { iMessageType=ESMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntrySMSOutbox: { iMessageType=ESMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntrySMSSent: { iMessageType=ESMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryMMSInbox: { iMessageType=EMMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryMMSDrafts: { iMessageType=EMMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryMMSOutbox: { iMessageType=EMMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryMMSSent: { iMessageType=EMMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryEmailInbox: { iMessageType=EEmail; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryEmailDrafts: { iMessageType=EEmail; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryEmailOutbox: { iMessageType=EEmail; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryEmailSent: { iMessageType=EEmail; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryBIOInbox: { iMessageType=ESmartMessage; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBIODrafts: { iMessageType=ESmartMessage; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBIOOutbox: { iMessageType=ESmartMessage; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBIOSent: { iMessageType=ESmartMessage; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryIRInbox: { iMessageType=EIrMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryIRDrafts: { iMessageType=EIrMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryIROutbox: { iMessageType=EIrMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryIRSent: { iMessageType=EIrMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryBTInbox: { iMessageType=EBTMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBTDrafts: { iMessageType=EBTMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBTOutbox: { iMessageType=EBTMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryBTSent: { iMessageType=EBTMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}
+
+ case ECmdCreateRandomEntryAMSInbox: { iMessageType=EAMS; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryAMSDrafts: { iMessageType=EAMS; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryAMSOutbox: { iMessageType=EAMS; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}
+ case ECmdCreateRandomEntryAMSSent: { iMessageType=EAMS; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}
+
+ default: { User::Panic(_L("MessageCommand"), 901); break;}
+ }
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateMessageEntryL(CMessagesParameters *aParameters, TBool /*aTakeUserGivenParameters*/)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateMessageEntryL");
+
+ delete iParameters;
+ iParameters = 0;
+
+ CMessagesParameters* parameters = aParameters;
+
+ // random data needed if no predefined data available
+ if (!parameters)
+ {
+ iParameters = new(ELeave) CMessagesParameters;
+ parameters = iParameters;
+ // check if values from ui needed
+ //if (aTakeUserGivenParameters)
+ // {
+ parameters->iMessageType = iMessageType;
+ parameters->iFolderType = iFolderType;
+ parameters->iDefinedMessageLength = iDefinedMessageLength;
+ parameters->iCreateAsUnread = iCreateAsUnread;
+
+ for (TInt i=0; i<iAttachments->Count(); i++)
+ parameters->iAttachments->AppendL(iAttachments->At(i));
+ // }
+ //else
+ // {
+ // message length
+ // parameters->iDefinedMessageLength = iEngine->RandomNumber(100, 300);
+ // }
+
+ if (parameters->iMessageType == EEmail)
+ {
+ parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );
+ parameters->iSenderAddress->Des().Append( _L("@") );
+ parameters->iSenderAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );
+ parameters->iSenderAddress->Des().Append( _L(".com") );
+
+ parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );
+ parameters->iRecipientAddress->Des().Append( _L("@") );
+ parameters->iRecipientAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );
+ parameters->iRecipientAddress->Des().Append( _L(".net") );
+ }
+ else if (parameters->iMessageType == EIrMessage || parameters->iMessageType == EBTMessage)
+ {
+ parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );
+ parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );
+ }
+ else
+ {
+ parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );
+ parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );
+ }
+
+ // subject
+ parameters->iMessageSubject->Des() = iEngine->RandomString(CCreatorEngine::EMessageSubject);
+
+ // message body
+ parameters->iMessageBodyText->Des().Copy(_L(""));
+ TPtrC randText = iEngine->RandomString(CCreatorEngine::EMessageText);
+ for (TInt i=0; i<parameters->iDefinedMessageLength / randText.Length() +1; i++)
+ {
+ parameters->iMessageBodyText->Des().Append( randText );
+ parameters->iMessageBodyText->Des().Append( _L(" ") );
+ }
+ parameters->iMessageBodyText->Des() = parameters->iMessageBodyText->Des().Left(parameters->iDefinedMessageLength);
+
+ // BIO message type (from bitsids.h) // TO-DO: add support for all BIO message types...
+ parameters->iBIOMessageType = KUidBIOBusinessCardMsg;
+ }
+
+
+
+ TInt err = KErrNone;
+
+ switch (parameters->iMessageType)
+ {
+ case ESMS: { err = CreateSMSEntryL(*parameters); break; }
+ case EMMS: { err = CreateMMSEntryL(*parameters); break; }
+ case EAMS: { err = CreateAMSEntryL(*parameters); break; }
+ case EEmail: { err = CreateEmailEntryL(*parameters); break; }
+ case ESmartMessage: { err = CreateSmartMessageEntryL(*parameters); break; }
+ case EIrMessage: { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeIrTInt32), *parameters ); break; }
+ case EBTMessage: { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeBtTInt32), *parameters ); break; }
+ default: { User::Panic(_L("MsgType"), 851); break;}
+
+ }
+
+ iSenderArray.ResetAndDestroy();
+ iRecipientArray.ResetAndDestroy();
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateSMSEntryL(const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateSMSEntryL");
+
+ TInt err = KErrNone;
+
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CSmsClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CSmsClientMtm*>(registry->NewMtmL(KUidMsgTypeSMS)));
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // get default service
+ TMsvId defaultServiceId = 0;
+ TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());
+ if (err)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Define a SMS centre first"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // set the from field to sms header
+ // !!! This will cause CRASH
+ /*if (parameters.iFolderType == EInbox)
+ {
+ CSmsHeader* smsHeader = &clientMtm->SmsHeader();
+ delete smsHeader; // <-- This will cause CRASH
+ smsHeader = NULL;
+ smsHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, clientMtm->Body());
+ if( parameters.iSenderAddress )
+ {
+ smsHeader->SetFromAddressL( parameters.iSenderAddress->Des() );
+ }
+ else
+ {
+ smsHeader->SetFromAddressL(KEmpty);
+ }
+ } */
+
+ // set body
+ clientMtm->Body().Reset();
+ clientMtm->Body().InsertL(0, parameters.iMessageBodyText->Des());
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // set the details field
+ if (parameters.iFolderType == EInbox)
+ {
+ SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+ else
+ {
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ // Add all recipients to clientMtm
+ // iRecipientArray is up-to-date so don't call AddRecipientsL here
+ for( TInt i = 0; i < iRecipientArray.Count(); i++ )
+ {
+ clientMtm->AddAddresseeL( iRecipientArray[i]->Des() );
+ }
+ }
+
+ // set the sending state for outbox message
+ // to avoid SMSMtmUI:15 panic in messages application
+ if (parameters.iFolderType == EOutbox )
+ {
+ messageEntry.SetSendingState( KMsvSendStateWaiting );
+ }
+
+ // set the description field same as the first part of the message body
+ messageEntry.iDescription.Set( parameters.iMessageBodyText->Des().Left(KSmsDescriptionLength) );
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ messageEntry.SetAttachment(EFalse);
+ messageEntry.iDate.HomeTime();
+ messageEntry.SetVisible(ETrue);
+ messageEntry.SetInPreparation(EFalse);
+
+ if (parameters.iCreateAsUnread)
+ {
+ messageEntry.SetUnread(ETrue);
+ messageEntry.SetNew(ETrue);
+ }
+ else
+ {
+ messageEntry.SetUnread(EFalse);
+ messageEntry.SetNew(EFalse);
+ }
+
+ messageEntry.SetComplete(ETrue);
+ messageEntry.iServiceId = defaultServiceId;
+ messageEntry.iRelatedId = 0;
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+ return err;
+
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateMMSEntryL(const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateMMSEntryL");
+
+ TInt err = KErrNone;
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CMmsClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CMmsClientMtm*>(registry->NewMtmL(KUidMsgTypeMultimedia)));
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // get default service
+ TMsvId defaultServiceId = 0;
+ TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());
+ if (err)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Define MMS settings first"));
+ CleanupStack::PopAndDestroy(4);
+ User::Leave(KErrNotFound);
+ }
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // set subject
+ clientMtm->SetSubjectL( parameters.iMessageSubject->Des() );
+
+ // set some mms defaults
+ clientMtm->SetMessageClass(EMmsClassPersonal);
+ clientMtm->SetExpiryInterval(86400);
+ clientMtm->SetDeliveryTimeInterval(3600);
+ clientMtm->SetMessagePriority(EMmsPriorityLow);
+ clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);
+ clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);
+ clientMtm->SetReadReply(EMmsReadReplyYes);
+
+ // set the sender / addressee field
+ if (parameters.iFolderType == EInbox)
+ {
+ AddMtmSenderL(*clientMtm, parameters, EFalse);
+ }
+
+ // Add all recipients to clientMtm
+ AddRecipientsL( *clientMtm, parameters, EFalse );
+
+ // get an access to the message store
+ CMsvStore* store = msvEntry->EditStoreL();
+ CleanupStack::PushL(store);
+
+
+ // set body as an attachment
+ CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
+ CleanupStack::PushL(mimeHeaders);
+ mimeHeaders->SetContentTypeL( _L8("text") );
+ mimeHeaders->SetContentSubTypeL( _L8("plain") );
+ mimeHeaders->SetMimeCharset( KMmsUtf8 );
+ mimeHeaders->SetSuggestedFilenameL( _L("body.txt") );
+
+ MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+ CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred
+ CleanupStack::PushL(attachmentInfo);
+ attachmentInfo->SetAttachmentNameL( _L("body.txt") );
+ attachmentInfo->SetMimeTypeL( _L8("text/plain") );
+ mimeHeaders->StoreL( *attachmentInfo );
+
+ RFile textFile;
+
+ CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+ attachMan.CreateAttachmentL(_L("body.txt"), textFile, attachmentInfo, waiter->iStatus );
+ CleanupStack::Pop(); // waiter
+ CleanupStack::Pop(); // attachmentInfo
+ CleanupStack::PushL(waiter);
+ waiter->StartAndWait();
+ CleanupStack::PopAndDestroy(waiter);
+
+ HBufC8* tempBuf = CnvUtfConverter::ConvertFromUnicodeToUtf8L( parameters.iMessageBodyText->Des() );
+ CleanupStack::PushL(tempBuf);
+ textFile.Write( tempBuf->Des() );
+ textFile.Close();
+ CleanupStack::PopAndDestroy(); //tempBuf
+
+ CleanupStack::PopAndDestroy(); //mimeHeaders
+
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // set the details field
+ if (parameters.iFolderType == EInbox)
+ {
+ SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+ else
+ {
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+
+ // set the description field same as the message subject
+ messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+
+ // save the attachments
+ HandleAttachementsL(parameters, store, err );
+// for (TInt i=0; i<parameters.iAttachments->Count(); i++)
+// {
+// TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );
+//
+// TParse parser;
+// parser.Set(sourceFileName, NULL, NULL);
+// TFileName shortFileName = parser.NameAndExt();
+//
+// // get the mime type
+// RApaLsSession ls;
+// User::LeaveIfError(ls.Connect());
+// CleanupClosePushL<RApaLsSession>(ls);
+// TUid appUid;
+// TDataType dataType;
+// ls.AppForDocument(sourceFileName, appUid, dataType);
+// CleanupStack::PopAndDestroy(); //ls
+// TPtrC8 mimeType = dataType.Des8();
+//
+// // attachment settings
+// MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+// CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred
+// attachmentInfo->SetAttachmentNameL( shortFileName );
+// attachmentInfo->SetMimeTypeL( mimeType );
+//
+// // save
+// CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+//
+// TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));
+// if (err == KErrNone)
+// waiter->StartAndWait();
+// else
+// LOGSTRING2("Creator: CCreatorMessages::CreateMMSEntryL failed to attach %S", &sourceFileName);
+//
+// CleanupStack::PopAndDestroy(waiter);
+// }
+
+ // save the changes made to the message store
+ store->CommitL();
+ CleanupStack::PopAndDestroy(store);
+
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ messageEntry.SetAttachment(ETrue);
+ messageEntry.iDate.HomeTime();
+ messageEntry.SetVisible(ETrue);
+ messageEntry.SetInPreparation(EFalse);
+ if (parameters.iCreateAsUnread)
+ {
+ messageEntry.SetUnread(ETrue);
+ messageEntry.SetNew(ETrue);
+ }
+ else
+ {
+ messageEntry.SetUnread(EFalse);
+ messageEntry.SetNew(EFalse);
+ }
+ messageEntry.SetComplete(ETrue);
+ messageEntry.iServiceId = defaultServiceId;
+ messageEntry.iRelatedId = 0;
+
+ if (parameters.iFolderType == EDrafts)
+ messageEntry.SetReadOnly(EFalse);
+ else
+ messageEntry.SetReadOnly(ETrue);
+
+ messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;
+
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::HandleAttachementsL(const CMessagesParameters& parameters, CMsvStore* store, TInt err )
+ {
+ // save the attachments (added with id's)
+ for (TInt i=0; i<parameters.iAttachments->Count(); i++)
+ {
+ TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );
+ HandleAttachementL(store, err, sourceFileName );
+
+ }
+ //Adding attachmentpaths
+ for (TInt i=0; i<parameters.iAttachmentPaths.Count(); i++)
+ {
+ HBufC* point = parameters.iAttachmentPaths[i];
+ TFileName sourceFileName(point->Des());
+ HandleAttachementL(store, err, sourceFileName );
+ }
+ }
+//----------------------------------------------------------------------------
+
+void CCreatorMessages::HandleAttachementL(CMsvStore* store, TInt err, TFileName& sourceFileName )
+ {
+ TParse parser;
+ parser.Set(sourceFileName, NULL, NULL);
+ TFileName shortFileName = parser.NameAndExt();
+
+ // get the mime type
+ RApaLsSession ls;
+ User::LeaveIfError(ls.Connect());
+ CleanupClosePushL<RApaLsSession>(ls);
+ TUid appUid;
+ TDataType dataType;
+ ls.AppForDocument(sourceFileName, appUid, dataType);
+ CleanupStack::PopAndDestroy(); //ls
+ TPtrC8 mimeType = dataType.Des8();
+
+ // attachment settings
+ MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+ CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred
+ CleanupStack::PushL(attachmentInfo);
+ attachmentInfo->SetAttachmentNameL( shortFileName );
+ attachmentInfo->SetMimeTypeL( mimeType );
+
+ if ( mimeType == _L8("text/plain") )
+ {
+ // CMsvMimeHeaders needs to be stored in case of text file
+ CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
+ CleanupStack::PushL(mimeHeaders);
+ mimeHeaders->SetContentTypeL( _L8("text") );
+ mimeHeaders->SetContentSubTypeL( _L8("plain") );
+ mimeHeaders->SetMimeCharset( KMmsUtf8 );
+ mimeHeaders->StoreL( *attachmentInfo );
+ CleanupStack::PopAndDestroy( mimeHeaders );
+ }
+
+ // save
+
+ CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+ TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));
+ if (err == KErrNone)
+ {
+ waiter->StartAndWait();
+ CleanupStack::PopAndDestroy(waiter);
+ CleanupStack::Pop(); // attachmentInfo, the ownership is transferred
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(waiter);
+ CleanupStack::PopAndDestroy(); // attachmentInfo, ownership is not transferred (leave occurs)
+ LOGSTRING2("Creator: CCreatorMessages::HandleAttachementsL failed to attach %S", &sourceFileName);
+ }
+ }
+ //----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateAMSEntryL(const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateAMSEntryL");
+
+ TInt err = KErrNone;
+
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CMmsClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CMmsClientMtm*>(registry->NewMtmL(KUidMsgTypeMultimedia)));
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // get default service
+ TMsvId defaultServiceId = 0;
+ TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());
+ if (err)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Define MMS settings first"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // set subject
+ clientMtm->SetSubjectL(parameters.iMessageSubject->Des() );
+
+ // set some mms defaults
+ clientMtm->SetMessageClass(EMmsClassPersonal);
+ clientMtm->SetExpiryInterval(86400);
+ clientMtm->SetDeliveryTimeInterval(3600);
+ clientMtm->SetMessagePriority(EMmsPriorityLow);
+ clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);
+ clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);
+ clientMtm->SetReadReply(EMmsReadReplyYes);
+
+ // set the sender / addressee field
+ if (parameters.iFolderType == EInbox)
+ {
+ AddMtmSenderL(*clientMtm, parameters, EFalse);
+ }
+
+ // Add all recipients to clientMtm
+ AddRecipientsL( *clientMtm, parameters, EFalse );
+
+
+ // get an access to the message store
+ CMsvStore* store = msvEntry->EditStoreL();
+ CleanupStack::PushL(store);
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // set the details field
+ if (parameters.iFolderType == EInbox)
+ {
+ SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+ else
+ {
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+
+ // set the description field same as the message subject
+ messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );
+ messageEntry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+
+ TFileName sourceFileName = iEngine->TestDataPathL( CCreatorEngine::EAMR_20kB );
+ TParse parser;
+ parser.Set(sourceFileName, NULL, NULL);
+ TFileName shortFileName = parser.NameAndExt();
+
+ // get the mime type
+ RApaLsSession ls;
+ User::LeaveIfError(ls.Connect());
+ CleanupClosePushL<RApaLsSession>(ls);
+ TUid appUid;
+ TDataType dataType;
+ ls.AppForDocument(sourceFileName, appUid, dataType);
+ CleanupStack::PopAndDestroy(); //ls
+ TPtrC8 mimeType = dataType.Des8();
+
+ // attachment settings
+ MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+ CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred
+ attachmentInfo->SetAttachmentNameL( shortFileName );
+ attachmentInfo->SetMimeTypeL( mimeType );
+
+ // save
+ CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+
+ TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));
+ if (err == KErrNone)
+ waiter->StartAndWait();
+ else
+ LOGSTRING2("Creator: CCreatorMessages::CreateAMSEntryL failed to attach %S", &sourceFileName);
+
+ CleanupStack::PopAndDestroy(waiter);
+
+ // save the changes made to the message store
+ store->CommitL();
+ CleanupStack::PopAndDestroy(store);
+
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ messageEntry.SetAttachment(ETrue);
+ messageEntry.iDate.HomeTime();
+ messageEntry.SetVisible(ETrue);
+ messageEntry.SetInPreparation(EFalse);
+ if (parameters.iCreateAsUnread)
+ {
+ messageEntry.SetUnread(ETrue);
+ messageEntry.SetNew(ETrue);
+ }
+ else
+ {
+ messageEntry.SetUnread(EFalse);
+ messageEntry.SetNew(EFalse);
+ }
+ messageEntry.SetComplete(ETrue);
+ messageEntry.iServiceId = defaultServiceId;
+ messageEntry.iRelatedId = 0;
+
+ if (parameters.iFolderType == EDrafts)
+ messageEntry.SetReadOnly(EFalse);
+ else
+ messageEntry.SetReadOnly(ETrue);
+
+ messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;
+
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateEmailEntryL(const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateEmailEntryL");
+
+ TInt err = KErrNone;
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CSmtpClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CSmtpClientMtm*>(registry->NewMtmL(KUidMsgTypeSMTP)));
+
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("Email: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // get default service
+ TMsvId defaultServiceId(0);
+ TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());
+ if (err)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("Email: Define a mailbox first"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ case EMailbox: { msvEntry->SetEntryL(iUserSelectedMailbox); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // set subject
+ clientMtm->SetSubjectL( parameters.iMessageSubject->Des() );
+
+ // set body
+ clientMtm->Body().Reset();
+ clientMtm->Body().InsertL(0, parameters.iMessageBodyText->Des());
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // set the address fields
+ if (parameters.iFolderType == EInbox)
+ {
+ AddSenderToMtmAddresseeL(*clientMtm, parameters, ETrue );
+ SetSenderToEntryDetailsL(messageEntry, parameters, ETrue);
+ messageEntry.iMtm = KUidMsgTypeIMAP4; // or any other than KUidMsgTypeSMTP to display 'from' field instead of 'to' field
+ }
+ else
+ {
+ // Add all recipients to clientMtm
+ AddRecipientsL( *clientMtm, parameters, ETrue );
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+
+ // set the description field same as the message subject
+ messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // get an access to the message store
+ CMsvStore* store = msvEntry->EditStoreL();
+ CleanupStack::PushL(store);
+
+ // save the attachments
+ HandleAttachementsL(parameters, store, err);
+// for (TInt i=0; i<parameters.iAttachments->Count(); i++)
+// {
+// TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );
+//
+// TParse parser;
+// parser.Set(sourceFileName, NULL, NULL);
+// TFileName shortFileName = parser.NameAndExt();
+//
+// // get the mime type
+// RApaLsSession ls;
+// User::LeaveIfError(ls.Connect());
+// CleanupClosePushL<RApaLsSession>(ls);
+// TUid appUid;
+// TDataType dataType;
+// ls.AppForDocument(sourceFileName, appUid, dataType);
+// CleanupStack::PopAndDestroy(); //ls
+// TPtrC8 mimeType = dataType.Des8();
+//
+// // attachment settings
+// MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+// CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred
+// attachmentInfo->SetAttachmentNameL( shortFileName );
+// attachmentInfo->SetMimeTypeL( mimeType );
+//
+// // save
+// CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+//
+// TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));
+// if (err == KErrNone)
+// waiter->StartAndWait();
+// else
+// LOGSTRING2("Creator: CCreatorMessages::CreateEmailEntryL failed to attach %S", &sourceFileName);
+//
+// CleanupStack::PopAndDestroy(waiter);
+// }
+
+ // save the changes made to the message store
+ store->CommitL();
+ CleanupStack::PopAndDestroy(store);
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ TMsvEmailEntry temailEntry = static_cast<TMsvEmailEntry>(messageEntry);
+ temailEntry.SetMessageFolderType(EFolderTypeUnknown);
+ temailEntry.SetDisconnectedOperation(ENoDisconnectedOperations);
+ temailEntry.SetEncrypted(EFalse);
+ temailEntry.SetSigned(EFalse);
+ temailEntry.SetVCard(EFalse);
+ temailEntry.SetVCalendar(EFalse);
+ temailEntry.SetReceipt(EFalse);
+ temailEntry.SetMHTMLEmail(EFalse);
+ temailEntry.SetBodyTextComplete(ETrue);
+
+ if (parameters.iAttachments->Count() > 0)
+ temailEntry.SetAttachment(ETrue);
+ else
+ temailEntry.SetAttachment(EFalse);
+
+ temailEntry.iDate.HomeTime();
+ temailEntry.SetVisible(ETrue);
+ temailEntry.SetInPreparation(EFalse);
+ if (parameters.iCreateAsUnread)
+ {
+ temailEntry.SetUnread(ETrue);
+ temailEntry.SetNew(ETrue);
+ }
+ else
+ {
+ temailEntry.SetUnread(EFalse);
+ temailEntry.SetNew(EFalse);
+ }
+ temailEntry.SetComplete(ETrue);
+ temailEntry.iServiceId = defaultServiceId;
+ temailEntry.iRelatedId = 0;
+
+ clientMtm->Entry().ChangeL(temailEntry);
+
+ // reset email headers
+ CImHeader* header = CImHeader::NewLC();
+ CMsvStore* msvStore = msvEntry->EditStoreL();
+ CleanupStack::PushL(msvStore);
+ header->RestoreL(*msvStore);
+ header->SetSubjectL( parameters.iMessageSubject->Des() );
+ if( iSenderArray.Count() == 0 )
+ {
+ GetSendersL(iSenderArray, parameters, ETrue, KUndef );
+ }
+
+ if( iSenderArray.Count() > 0 )
+ {
+ TInt rndNum = iEngine->RandomNumber( iSenderArray.Count() );
+ header->SetFromL(iSenderArray[rndNum]->Des());
+ }
+ else
+ {
+ header->SetFromL( parameters.iSenderAddress->Des() );
+ }
+ if( parameters.iRecipientAddress->Length() > 0 )
+ {
+ header->SetReceiptAddressL( parameters.iRecipientAddress->Des() );
+ }
+ else if( parameters.iRecipientAddressArray.Count() > 0 )
+ {
+ header->SetReceiptAddressL( parameters.iRecipientAddressArray[0]->Des());
+ }
+
+ header->StoreL( *msvStore );
+ msvStore->CommitL();
+ CleanupStack::PopAndDestroy(2); // msvStore, header
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateSmartMessageEntryL(const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateSmartMessageEntryL");
+
+ TInt err = KErrNone;
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CSmsClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CSmsClientMtm*>(registry->NewMtmL(KUidMsgTypeSMS)));
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("BIO: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // get default service
+ TMsvId defaultServiceId = 0;
+ TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());
+ if (err)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Define a SMS centre first"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // set the from field to sms header
+ if (parameters.iFolderType == EInbox)
+ {
+ CSmsHeader* smsHeader = &clientMtm->SmsHeader();
+ delete smsHeader;
+ smsHeader = NULL;
+ smsHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, clientMtm->Body());
+ if( parameters.iSenderAddress )
+ {
+ smsHeader->SetFromAddressL( parameters.iSenderAddress->Des() );
+ }
+ else
+ {
+ smsHeader->SetFromAddressL(KEmpty);
+ }
+ }
+
+ // set body, the BIO message itself
+ clientMtm->Body().Reset();
+ clientMtm->Body().InsertL(0, _L("Business Card\nTester Mike\nThe Company Ltd.\nSoftware Engineer\ntel +358 66 1234567\n"));
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // TO-DO: Add support for all BIO messages, currently just insert a business card message ... :
+ // set the message type
+ // parameters.iBIOMessageType ...
+ clientMtm->BioTypeChangedL(KUidBIOBusinessCardMsg);
+ messageEntry.iBioType = KUidBIOBusinessCardMsg.iUid;
+
+ // set the details field
+ if (parameters.iFolderType == EInbox)
+ {
+ SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+ else
+ {
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+
+ // set the subject line
+ messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );
+
+ // set correct MTM type
+ messageEntry.iMtm= KUidBIOMessageTypeMtm;
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ messageEntry.SetAttachment(EFalse);
+ messageEntry.iDate.HomeTime();
+ messageEntry.SetVisible(ETrue);
+ messageEntry.SetInPreparation(EFalse);
+ if (parameters.iCreateAsUnread)
+ {
+ messageEntry.SetUnread(ETrue);
+ messageEntry.SetNew(ETrue);
+ }
+ else
+ {
+ messageEntry.SetUnread(EFalse);
+ messageEntry.SetNew(EFalse);
+ }
+ messageEntry.SetComplete(ETrue);
+ messageEntry.iServiceId = defaultServiceId;
+ messageEntry.iRelatedId = 0;
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+TInt CCreatorMessages::CreateObexEntryL(TUid aMtm, const CMessagesParameters& parameters)
+ {
+ LOGSTRING("Creator: CCreatorMessages::CreateObexEntryL");
+
+ TInt err = KErrNone;
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL(session);
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL(registry);
+
+ // get the client mtm and return if it isn't supported in the system
+ CObexClientMtm* clientMtm = NULL;
+ TRAP(err, clientMtm = static_cast<CObexClientMtm*>(registry->NewMtmL(aMtm)));
+ if (err || !clientMtm)
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage(_L("Obex: Message type module not found"));
+ CleanupStack::PopAndDestroy(2);
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(clientMtm);
+
+ // create a new object to access an existing entry
+ CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+ CleanupStack::PushL(msvEntry);
+
+ // define default service
+ TMsvId defaultServiceId = 0;
+
+ // set folder type
+ switch (parameters.iFolderType)
+ {
+ case EInbox: { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId); break; }
+ case EDrafts: { msvEntry->SetEntryL(KMsvDraftEntryId); break; }
+ case EOutbox: { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId); break; }
+ case ESent: { msvEntry->SetEntryL(KMsvSentEntryId); break; }
+ default: { User::Panic(_L("Folder Type"), 871); break; }
+ }
+
+ // mtm takes ownership of entry context
+ CleanupStack::Pop(msvEntry);
+ clientMtm->SetCurrentEntryL(msvEntry);
+
+ // create a new message
+ clientMtm->CreateMessageL(defaultServiceId);
+
+ // get the entry of the message
+ TMsvEntry messageEntry = clientMtm->Entry().Entry();
+
+ // set subject
+ clientMtm->SetSubjectL( parameters.iMessageSubject->Des() );
+ messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );
+
+ // set body, must be empty for obex messages
+ clientMtm->Body().Reset();
+
+ // set the details field and
+ if (parameters.iFolderType == EInbox)
+ {
+ SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+ else
+ {
+ SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);
+ }
+
+ // set mtm
+ messageEntry.iMtm = aMtm;
+ messageEntry.iType = KUidMsvMessageEntry;
+ messageEntry.iServiceId = KMsvUnknownServiceIndexEntryId;
+
+ // save the changes done above
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // save the message
+ clientMtm->SaveMessageL();
+
+ // final fine tuning
+ messageEntry.iDate.HomeTime();
+ messageEntry.SetVisible(ETrue);
+ messageEntry.SetInPreparation(EFalse);
+ if (parameters.iCreateAsUnread)
+ {
+ messageEntry.SetUnread(ETrue);
+ messageEntry.SetNew(ETrue);
+ }
+ else
+ {
+ messageEntry.SetUnread(EFalse);
+ messageEntry.SetNew(EFalse);
+ }
+ messageEntry.SetComplete(ETrue);
+ clientMtm->Entry().ChangeL(messageEntry);
+
+ // save the attachment
+ if (parameters.iAttachments->Count() >= 1)
+ {
+ // create a new entry for the attachment
+ TMsvEntry attachTEntry;
+ attachTEntry.iType = KUidMsvAttachmentEntry;
+ attachTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;
+ attachTEntry.iMtm = KUidMsgTypeBt; //save as bt message
+
+ msvEntry->CreateL(attachTEntry);
+
+ CMsvEntry* attachEntry = session->GetEntryL(attachTEntry.Id());
+ clientMtm->SetCurrentEntryL(attachEntry);
+
+ // get source file
+ TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(0) );
+
+ // get the mime type
+ RApaLsSession ls;
+ User::LeaveIfError(ls.Connect());
+ CleanupClosePushL<RApaLsSession>(ls);
+ TUid appUid;
+ TDataType mimeType;
+ ls.AppForDocument(sourceFileName, appUid, mimeType);
+ CleanupStack::PopAndDestroy(); //ls
+
+ CAsyncWaiter* waiter = CAsyncWaiter::NewLC();
+
+ // add an attachment to the current message entry
+ TRAP(err, clientMtm->AddAttachmentL( sourceFileName, mimeType.Des8(), 0, waiter->iStatus ));
+ if (err == KErrNone)
+ waiter->StartAndWait();
+ else
+ LOGSTRING2("Creator: CCreatorMessages::CreateObexEntryL failed to attach %S", &sourceFileName);
+
+ CleanupStack::PopAndDestroy(waiter);
+ }
+
+ // id has been generated, store it for being able to delete
+ // only entries created with Creator
+ iEntryIds.AppendL( messageEntry.Id() );
+
+ CleanupStack::PopAndDestroy(3); //session, registry, clientMtm
+
+
+ return err;
+ }
+
+//----------------------------------------------------------------------------
+
+void CCreatorMessages::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) // from MMsvSessionObserver
+ {
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::SetSenderToEntryDetailsL(TMsvEntry& aMsgEntry, const CMessagesParameters& aParameters, TBool aUseEmailAddress)
+ {
+ // Only one sender allowed:
+ if( iSenderArray.Count() == 0 )
+ {
+ GetSendersL(iSenderArray, aParameters, aUseEmailAddress, KUndef );
+ }
+ if( iSenderArray.Count() > 0 )
+ {
+ TInt rnd = iEngine->RandomNumber( iSenderArray.Count() );
+ aMsgEntry.iDetails.Set( iSenderArray[rnd]->Des() );
+ }
+ else
+ {
+ aMsgEntry.iDetails.Set(KEmpty);
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::SetRecipientToEntryDetailsL(TMsvEntry& aMsgEntry, const CMessagesParameters& aParameters, TBool aUseEmailAddress)
+ {
+ // Only one sender allowed:
+ GetAllRecipientsL(iRecipientArray, aParameters, aUseEmailAddress);
+ if( iRecipientArray.Count() > 0 )
+ {
+ const TDesC& temp = iRecipientArray[0]->Des();
+ aMsgEntry.iDetails.Set( temp );
+ }
+ else
+ {
+ aMsgEntry.iDetails.Set(KEmpty);
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::AddSenderToMtmAddresseeL(CBaseMtm& aMtm, const CMessagesParameters& aParameters, TBool aUseEmailAddress )
+ {
+ // Only one sender allowed:
+ if( iSenderArray.Count() == 0 )
+ {
+ GetSendersL(iSenderArray, aParameters, aUseEmailAddress, 1 );
+ }
+
+ for( TInt i = 0; i < iSenderArray.Count(); ++i )
+ {
+ aMtm.AddAddresseeL( iSenderArray[i]->Des() );
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::AddMtmSenderL(CMmsClientMtm& aMtm, const CMessagesParameters& aParameters, TBool aUseEmailAddress )
+ {
+ // Only one sender allowed:
+ if( iSenderArray.Count() == 0 )
+ {
+ GetSendersL(iSenderArray, aParameters, aUseEmailAddress, 1 );
+ }
+
+ if( iSenderArray.Count() > 0 )
+ {
+ aMtm.SetSenderL( iSenderArray[0]->Des() );
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::GetSendersL(RPointerArray<HBufC>& aSenderArray, const CMessagesParameters& aParameters, TBool aUseEmailAddress, TInt aMaxNum )
+ {
+ TInt counter = 0;
+
+ if( counter < aMaxNum || aMaxNum == KUndef )
+ {
+ if( aParameters.iSenderAddress && aParameters.iSenderAddress->Length() > 0 )
+ {
+ HBufC* temp = HBufC::NewL(aParameters.iSenderAddress->Length());
+ CleanupStack::PushL(temp);
+ temp->Des().Copy(aParameters.iSenderAddress->Des());
+ aSenderArray.AppendL( temp );
+ CleanupStack::Pop(); // temp
+ ++counter;
+ }
+ }
+
+ if( counter < aMaxNum || aMaxNum == KUndef )
+ {
+ RPointerArray<HBufC> tempArray;
+ CleanupResetAndDestroyPushL( tempArray );
+ GetLinkedAddressesL(tempArray, aParameters.iSenderLinkIds, aUseEmailAddress, aParameters.iNumberOfExistingSenders);
+ for( TInt i = 0; i < tempArray.Count() && (counter < aMaxNum || aMaxNum == KUndef); ++i )
+ {
+ HBufC* temp = tempArray[i]->AllocLC();
+ aSenderArray.AppendL(temp);
+ CleanupStack::Pop(); // temp
+ ++counter;
+ }
+ CleanupStack::PopAndDestroy(); // tempArray
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::AddRecipientsL(CBaseMtm& aMtm, const CMessagesParameters& aParameters, TBool aUseEmailAddress )
+ {
+ GetAllRecipientsL(iRecipientArray, aParameters, aUseEmailAddress);
+ for( TInt i = 0; i < iRecipientArray.Count(); ++i )
+ {
+ aMtm.AddAddresseeL( iRecipientArray[i]->Des() );
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::GetAllRecipientsL(RPointerArray<HBufC>& aRecipientArray, const CMessagesParameters& aParameters, TBool aUseEmailAddress )
+ {
+
+ // If iRecipientAddress is given, add it to the array:
+ if( aParameters.iRecipientAddress && aParameters.iRecipientAddress->Length() > 0 )
+ {
+ HBufC* temp = HBufC::NewL(aParameters.iRecipientAddress->Length());
+ CleanupStack::PushL(temp);
+ temp->Des().Copy(aParameters.iRecipientAddress->Des());
+ aRecipientArray.AppendL( temp );
+ CleanupStack::Pop(); // temp
+ }
+
+ // Add all recipients listed in iRecipientAddressArray:
+ for( TInt i = 0; i < aParameters.iRecipientAddressArray.Count(); ++i )
+ {
+ HBufC* temp = HBufC::NewL(aParameters.iRecipientAddressArray[i]->Length());
+ CleanupStack::PushL(temp);
+ temp->Des().Copy(aParameters.iRecipientAddressArray[i]->Des());
+ aRecipientArray.AppendL( temp );
+ CleanupStack::Pop(); // temp
+ }
+
+ // Get all linked addresses.
+ GetLinkedAddressesL(aRecipientArray, aParameters.iRecipientLinkIds, aUseEmailAddress, aParameters.iNumberOfExistingRecipients);
+ }
+
+/*
+ * Get all linked addresses. This method gets addresses that are linked with contact-set id and
+ * existing addresses from the contact database, if required.
+ */
+void CCreatorMessages::GetLinkedAddressesL(
+ RPointerArray<HBufC>& aAddressArray,
+ const RArray<TLinkIdParam>& aLinkIds,
+ TBool aUseEmailAddress,
+ TInt /*aNumOfExistingAddresses*/ )
+ {
+ CCreatorPhonebook* phonebook = dynamic_cast<CCreatorPhonebook*>(iEngine->GetPhonebook());
+ User::LeaveIfNull( phonebook );
+ CCreatorPhonebookWrapper* phonebookWrapper = phonebook->GetPhonebookWrapper();
+
+ for( TInt i = 0; i < aLinkIds.Count(); ++i )
+ {
+ const CCreatorContactSet& set = ContactLinkCache::Instance()->ContactSet(aLinkIds[i].iLinkId);
+ const RArray<TUint32> links = set.ContactLinks();//ContactLinkCache::Instance()->ContactSets();//set.ContactLinks();
+ TInt numberOfExplicitLinks = links.Count(); // Number of defined contacts in contact-set
+ for( TInt j = 0; j < numberOfExplicitLinks; ++j )
+ {
+ TBuf<128> name;
+ TBuf<128> email;
+ TBuf<128> phoneNumber;
+ phonebookWrapper->GetContactDetailsL( links[j], name, phoneNumber, email );
+ HBufC* address = ( aUseEmailAddress ? email.AllocLC() : phoneNumber.AllocLC() );
+ aAddressArray.AppendL( address );
+ CleanupStack::Pop( address );
+ }
+ }
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::DeleteAllL()
+ {
+ LOGSTRING("Creator: CCreatorMessages::DeleteAllL");
+ DeleteAllMessagesL( EFalse );
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::DeleteAllMessagesL( TBool aOnlyCreatedWithCreator )
+ {
+ LOGSTRING("Creator: CCreatorMessages::DeleteAllMessagesL");
+ TInt err( KErrNone );
+
+ // init
+ CMsvSession* session = CMsvSession::OpenSyncL(*this);
+ CleanupStack::PushL( session );
+ CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);
+ CleanupStack::PushL( registry );
+
+ // get the client mtm and return if it isn't supported in the system
+ CSmsClientMtm* clientMtm( NULL );
+ TRAP( err, clientMtm = static_cast<CSmsClientMtm*>( registry->NewMtmL( KUidMsgTypeSMS ) ) );
+ if ( err || !clientMtm )
+ {
+ iEngine->GetEngineWrapper()->ShowErrorMessage( _L( "SMS: Message type module not found" ) );
+ CleanupStack::PopAndDestroy( 2 );
+ User::Leave( KErrNotFound );
+ }
+ CleanupStack::PushL( clientMtm );
+
+ TRAP_IGNORE( DeleteAllFromFolderL( KMsvGlobalInBoxIndexEntryId, session, clientMtm, aOnlyCreatedWithCreator ) );
+ TRAP_IGNORE( DeleteAllFromFolderL( KMsvDraftEntryId, session, clientMtm, aOnlyCreatedWithCreator ) );
+ TRAP_IGNORE( DeleteAllFromFolderL( KMsvGlobalOutBoxIndexEntryId, session, clientMtm, aOnlyCreatedWithCreator ) );
+ TRAP_IGNORE( DeleteAllFromFolderL( KMsvSentEntryId, session, clientMtm, aOnlyCreatedWithCreator ) );
+
+ // reset must be done here, because iEntryIds is stored in destructor
+ iEntryIds.Reset();
+
+ // all entries deleted, remove the Messages related registry
+ iEngine->RemoveStoreL( KUidDictionaryUidMessages );
+
+ CleanupStack::PopAndDestroy( clientMtm );
+ CleanupStack::PopAndDestroy( registry );
+ CleanupStack::PopAndDestroy( session );
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::DeleteAllFromFolderL( const TMsvId aContext,
+ CMsvSession* aSession,
+ CSmsClientMtm* aClientMtm,
+ TBool aOnlyCreatedWithCreator )
+ {
+ LOGSTRING("Creator: CCreatorMessages::DeleteAllFromFolderL");
+
+ TMsvSelectionOrdering sort;
+ sort.SetShowInvisibleEntries( ETrue );
+
+ CMsvEntry* inboxContext = CMsvEntry::NewL( *aSession, aContext, sort );
+ CleanupStack::PushL( inboxContext );
+
+ CMsvEntrySelection* entries = inboxContext->ChildrenL();
+ CleanupStack::PushL( entries );
+
+ TInt msgCount = entries->Count();
+ for ( TInt i = 0; i < entries->Count(); i++)
+ {
+ TMsvId entryID = entries->At(i);
+ aClientMtm->SwitchCurrentEntryL( entryID );
+
+ if ( !aOnlyCreatedWithCreator || iEntryIds.Find( entryID ) != KErrNotFound )
+ {
+ CMsvEntry* entry = aSession->GetEntryL( (*entries)[i] );
+ CleanupStack::PushL( entry );
+
+ entry->DeleteL( entries->At(i) );
+ CleanupStack::PopAndDestroy( entry );
+ }
+ }
+
+ CleanupStack::PopAndDestroy( entries );
+ CleanupStack::PopAndDestroy( inboxContext );
+ }
+
+//----------------------------------------------------------------------------
+void CCreatorMessages::DeleteAllCreatedByCreatorL()
+ {
+ LOGSTRING("Creator: CCreatorMessages::DeleteAllCreatedByCreatorL");
+
+ iEntryIds.Reset();
+
+ // fetch ids of entries created by Creator
+ iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidMessages );
+
+ // delete them
+ DeleteAllMessagesL( ETrue );
+ }
+
+CRecipientInfo::CRecipientInfo()
+ {
+
+ }
+
+CRecipientInfo::~CRecipientInfo()
+ {
+ delete iPhoneNumber;
+ delete iEmailAddress;
+ }
+
+void CRecipientInfo::SetPhoneNumber(HBufC* aPhone)
+ {
+ delete iPhoneNumber;
+ iPhoneNumber = aPhone;
+ }
+
+void CRecipientInfo::SetEmailAddress(HBufC* aEmail)
+ {
+ delete iEmailAddress;
+ iEmailAddress = aEmail;
+ }
+
+const HBufC* CRecipientInfo::PhoneNumber() const
+ {
+ return iPhoneNumber;
+ }
+
+const HBufC* CRecipientInfo::EmailAddress() const
+ {
+ return iEmailAddress;
+ }