1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "engine.h"

    20 #include "enginewrapper.h"

    21 

    22 #include "creator_message.h" 

    23 #include "creator_traces.h"

    24 #include "creator_contactsetcache.h"

    25 #include <apgcli.h>

    26 #include <MuiuServiceUtilities.h>

    27 #include <utf.h>

    28 

    29 #include <mmf/common/mmfcontrollerpluginresolver.h> // for CleanupResetAndDestroyPushL

    30 

    31 //static const TInt KMessagesFieldLength = 1024;

    32 

    33 //_LIT(KCreatorMessagesPrefixName, "CR_");

    34 //_LIT(KCreatorMessagesPrefixFolderName, "CR_FLDR_");

    35 

    36 

    37 const TUid KUidBIOBusinessCardMsg =  {0x10005531}; 

    38 _LIT(KEmpty, "");

    39 

    40 //----------------------------------------------------------------------------

    41 

    42 CMessagesParameters::CMessagesParameters()

    43     {

    44     LOGSTRING("Creator: CMessagesParameters::CMessagesParameters");

    45 

    46     iSenderAddress = HBufC::New(128);

    47     iRecipientAddress = HBufC::New(128);

    48     iMessageSubject = HBufC::New(128);

    49     iMessageBodyText = HBufC::New(10240);

    50     TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));

    51     iCreateAsUnread = ETrue;

    52     }

    53 

    54 CMessagesParameters::~CMessagesParameters()

    55     {

    56     LOGSTRING("Creator: CMessagesParameters::~CMessagesParameters");

    57 

    58 

    59     delete iMessageBodyText;

    60     delete iMessageSubject;

    61     delete iRecipientAddress;

    62     delete iSenderAddress;

    63     delete iAttachments;

    64     iAttachmentPaths.ResetAndDestroy();

    65     iAttachmentPaths.Close(); 

    66     iRecipientAddressArray.ResetAndDestroy();

    67     iRecipientAddressArray.Close();

    68     iRecipientLinkIds.Close();

    69     iSenderLinkIds.Close();

    70     }

    71 

    72 //----------------------------------------------------------------------------

    73 

    74 CCreatorMessages* CCreatorMessages::NewL(CCreatorEngine* aEngine)

    75     {

    76     CCreatorMessages* self = CCreatorMessages::NewLC(aEngine);

    77     CleanupStack::Pop(self);

    78     return self;

    79     }

    80 

    81 CCreatorMessages* CCreatorMessages::NewLC(CCreatorEngine* aEngine)

    82     {

    83     CCreatorMessages* self = new (ELeave) CCreatorMessages;

    84     CleanupStack::PushL(self);

    85     self->ConstructL(aEngine);

    86     return self;

    87     }

    88 

    89 CCreatorMessages::CCreatorMessages()

    90     {

    91     }

    92 

    93 void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)

    94     {

    95     LOGSTRING("Creator: CCreatorMessages::ConstructL");

    96     iEngine = aEngine;

    97     

    98     TRAP_IGNORE(iAttachments = new(ELeave) CArrayFixFlat<TInt>(64));

    99     iWaiter = CAsyncWaiter::NewL();

   100     }

   101 

   102 CCreatorMessages::~CCreatorMessages()

   103     {

   104     LOGSTRING("Creator: CCreatorMessages::~CCreatorMessages");

   105 

   106     if ( iEngine && iEntryIds.Count() )

   107         {

   108         TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidMessages ) );

   109         }

   110     iEntryIds.Reset();

   111     iEntryIds.Close();

   112     

   113     delete iParameters;

   114     delete iWaiter;

   115     delete iTmpPhoneNumber;

   116     delete iTmpEmail;

   117     delete iAttachments;

   118 

   119     iRecipientArray.ResetAndDestroy();

   120     iRecipientArray.Close();

   121     iSenderArray.ResetAndDestroy();

   122     iSenderArray.Close();

   123     }

   124 

   125 //----------------------------------------------------------------------------

   126 

   127 void CCreatorMessages::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)

   128     {

   129     LOGSTRING("Creator: CCreatorMessages::QueryDialogClosedL");  

   130     

   131     if( aPositiveAction == EFalse )

   132         {

   133         iEngine->ShutDownEnginesL();

   134         return;

   135         }

   136     

   137     const TDesC* showText = &KSavingText;

   138     TBool finished(EFalse);

   139     TBool retval(ETrue);

   140     switch(aUserData)

   141         {

   142         case ECreatorMessagesDelete:

   143             showText = &KDeletingText;

   144             iEntriesToBeCreated = 1;

   145             finished = ETrue;

   146             break;

   147         case ECreatorMessagesStart:

   148             // message type query

   149             retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message type"), R_MESSAGE_TYPE_QUERY, (TInt*) &iMessageType, this, ECreatorMessagesMessageType);

   150             break;

   151         case ECreatorMessagesMessageType:

   152             retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Folder type"), R_FOLDER_TYPE_QUERY, (TInt*) &iFolderType, this, ECreatorMessagesFolderType);

   153             break;

   154         case ECreatorMessagesFolderType:

   155             // query create as unread

   156             retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Message status"), R_UNREAD_QUERY, (TInt*)&iCreateAsUnread, this, ECreatorMessagesMessageStatus);

   157             break;

   158         case ECreatorMessagesMessageStatus:

   159             if( iMessageType == ESMS || iMessageType == EMMS || iMessageType == EEmail )

   160                 {

   161                 iDefinedMessageLength = 100;

   162                 retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iDefinedMessageLength, _L("Amount of characters in message body?"), ETrue, 

   163                     this, ECreatorMessagesCharsInBody

   164                     );

   165                 break;

   166                 }

   167             else

   168                 {

   169                 iDefinedMessageLength = 0;

   170                 // goto query attachments ... :-) DO NOT break;

   171                 }

   172         case ECreatorMessagesCharsInBody:

   173             // query attachments

   174             iAttachments->Reset();

   175             if( iMessageType == EMMS || iMessageType == EEmail)

   176                 {

   177                 retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_MULTI_SELECTION_QUERY, 

   178                     iAttachments, this, ECreatorMessagesAttachment

   179                     );

   180                 }

   181             else if( iMessageType == EAMS )

   182                 {

   183                 iAttachments->AppendL( TInt(0) );

   184                 retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY, 

   185                     &iAttachments->At(0), this, ECreatorMessagesAttachment

   186                     );

   187                 }

   188             else if( iMessageType == EIrMessage || iMessageType == EBTMessage )

   189                 {

   190                 iAttachments->AppendL( TInt(0) );

   191                 retval = iEngine->GetEngineWrapper()->ListQueryDialog(_L("Choose attachment:"), R_ATTACHMENT_SINGLE_SELECTION_QUERY,

   192                     &iAttachments->At(0), this, ECreatorMessagesAttachment

   193                     );

   194                 }

   195             else

   196                 {

   197                 finished = ETrue;

   198                 }

   199             break;

   200         case ECreatorMessagesAttachment:

   201             finished = ETrue;

   202             if(iMessageType== EMMS || iMessageType == EEmail)

   203                 {

   204                 // "none" is selected

   205                 if (iAttachments->At(0) == 0)

   206                     {

   207                     iAttachments->Reset();

   208                     }

   209                 else  // otherwise fix indexes

   210                     {

   211                     for (TInt i=0; i<iAttachments->Count(); i++)

   212                         iAttachments->At(i)--;  // decrease value by one 

   213 

   214                     }

   215                 }

   216             break;

   217         default:

   218             //some error

   219             retval = EFalse;

   220             break;

   221         }

   222     if( retval == EFalse )

   223         {

   224         iEngine->ShutDownEnginesL();

   225         }

   226     else if( finished )

   227         {

   228         // add this command to command array

   229         iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);

   230         // started exucuting commands

   231         iEngine->ExecuteFirstCommandL( *showText );

   232         }

   233     }

   234 //----------------------------------------------------------------------------

   235 

   236 TBool CCreatorMessages::AskDataFromUserL(TInt aCommand)

   237     {

   238     LOGSTRING("Creator: CCreatorMessages::AskDataFromUserL");

   239 

   240     CCreatorModuleBase::AskDataFromUserL(aCommand);

   241     

   242     if ( aCommand == ECmdDeleteMessages )

   243         {

   244         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages?"), this, ECreatorMessagesDelete );

   245         }

   246     else if ( aCommand ==  ECmdDeleteCreatorMessages )

   247         {

   248         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all messages created with Creator?"), this, ECreatorMessagesDelete  );

   249         }

   250 

   251     return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorMessagesStart );

   252     }

   253 

   254 //----------------------------------------------------------------------------

   255 

   256 TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)

   257     {

   258     LOGSTRING2("Creator: CCreatorMessages::CreateRandomMessageEntryL - Command: %d", aCommand);

   259 

   260     TInt err = KErrNone;

   261     

   262     iDefinedMessageLength = iEngine->RandomNumber(100, 300);

   263 

   264 

   265     switch (aCommand)

   266         {

   267 	    case ECmdCreateRandomEntrySMSInbox:     { iMessageType=ESMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

   268 	    case ECmdCreateRandomEntrySMSDrafts:    { iMessageType=ESMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

   269 	    case ECmdCreateRandomEntrySMSOutbox:    { iMessageType=ESMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

   270 	    case ECmdCreateRandomEntrySMSSent:      { iMessageType=ESMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

   271 	    

   272         case ECmdCreateRandomEntryMMSInbox:     { iMessageType=EMMS; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

   273 	    case ECmdCreateRandomEntryMMSDrafts:    { iMessageType=EMMS; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

   274 	    case ECmdCreateRandomEntryMMSOutbox:    { iMessageType=EMMS; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}    

   275 	    case ECmdCreateRandomEntryMMSSent:      { iMessageType=EMMS; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

   276 	    

   277         case ECmdCreateRandomEntryEmailInbox:   { iMessageType=EEmail; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

   278 	    case ECmdCreateRandomEntryEmailDrafts:  { iMessageType=EEmail; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

   279 	    case ECmdCreateRandomEntryEmailOutbox:  { iMessageType=EEmail; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

   280 	    case ECmdCreateRandomEntryEmailSent:    { iMessageType=EEmail; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

   281 	    

   282         case ECmdCreateRandomEntryBIOInbox:     { iMessageType=ESmartMessage; iFolderType=EInbox; err=CreateMessageEntryL(NULL); break;}

   283 	    case ECmdCreateRandomEntryBIODrafts:    { iMessageType=ESmartMessage; iFolderType=EDrafts; err=CreateMessageEntryL(NULL); break;}

   284 	    case ECmdCreateRandomEntryBIOOutbox:    { iMessageType=ESmartMessage; iFolderType=EOutbox; err=CreateMessageEntryL(NULL); break;}

   285 	    case ECmdCreateRandomEntryBIOSent:      { iMessageType=ESmartMessage; iFolderType=ESent; err=CreateMessageEntryL(NULL); break;}

   286 	    

   287         case ECmdCreateRandomEntryIRInbox:      { iMessageType=EIrMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   288 	    case ECmdCreateRandomEntryIRDrafts:     { iMessageType=EIrMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   289 	    case ECmdCreateRandomEntryIROutbox:     { iMessageType=EIrMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   290 	    case ECmdCreateRandomEntryIRSent:       { iMessageType=EIrMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   291 	    

   292         case ECmdCreateRandomEntryBTInbox:      { iMessageType=EBTMessage; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   293 	    case ECmdCreateRandomEntryBTDrafts:     { iMessageType=EBTMessage; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   294 	    case ECmdCreateRandomEntryBTOutbox:     { iMessageType=EBTMessage; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   295 	    case ECmdCreateRandomEntryBTSent:       { iMessageType=EBTMessage; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( iEngine->RandomNumber(CCreatorEngine::EJPEG_25kB, CCreatorEngine::LAST_FILE_ID-1) ); err=CreateMessageEntryL(NULL); break;}

   296         

   297 	    case ECmdCreateRandomEntryAMSInbox:     { iMessageType=EAMS; iFolderType=EInbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

   298 	    case ECmdCreateRandomEntryAMSDrafts:     { iMessageType=EAMS; iFolderType=EDrafts; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

   299 	    case ECmdCreateRandomEntryAMSOutbox:     { iMessageType=EAMS; iFolderType=EOutbox; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

   300 	    case ECmdCreateRandomEntryAMSSent:     { iMessageType=EAMS; iFolderType=ESent; iAttachments->Reset(); iAttachments->AppendL( CCreatorEngine::EMP3_250kB); err=CreateMessageEntryL(NULL); break;}

   301 

   302 	    default: { User::Panic(_L("MessageCommand"), 901);  break;}

   303         }

   304 

   305     return err;

   306     }

   307 

   308 //----------------------------------------------------------------------------

   309 

   310 TInt CCreatorMessages::CreateMessageEntryL(CMessagesParameters *aParameters, TBool /*aTakeUserGivenParameters*/)

   311     {

   312     LOGSTRING("Creator: CCreatorMessages::CreateMessageEntryL");

   313     

   314     delete iParameters;

   315     iParameters = 0;   

   316     

   317     CMessagesParameters* parameters = aParameters;

   318            

   319     // random data needed if no predefined data available

   320     if (!parameters)

   321         {

   322         iParameters = new(ELeave) CMessagesParameters;

   323         parameters = iParameters;

   324         // check if values from ui needed

   325         //if (aTakeUserGivenParameters)

   326         //    {            

   327             parameters->iMessageType = iMessageType;

   328             parameters->iFolderType = iFolderType;

   329             parameters->iDefinedMessageLength = iDefinedMessageLength;

   330             parameters->iCreateAsUnread = iCreateAsUnread;

   331 

   332             for (TInt i=0; i<iAttachments->Count(); i++)

   333                 parameters->iAttachments->AppendL(iAttachments->At(i)); 

   334         //    }

   335         //else

   336         //    {

   337             // message length

   338         //    parameters->iDefinedMessageLength = iEngine->RandomNumber(100, 300);

   339         //    }    

   340 

   341         if (parameters->iMessageType == EEmail)

   342             {

   343             parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

   344             parameters->iSenderAddress->Des().Append( _L("@") );

   345             parameters->iSenderAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );

   346             parameters->iSenderAddress->Des().Append( _L(".com") );

   347 

   348             parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

   349             parameters->iRecipientAddress->Des().Append( _L("@") );

   350             parameters->iRecipientAddress->Des().Append( iEngine->RandomString(CCreatorEngine::ECompany) );

   351             parameters->iRecipientAddress->Des().Append( _L(".net") );

   352             }

   353         else if (parameters->iMessageType == EIrMessage || parameters->iMessageType == EBTMessage)

   354             {

   355             parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

   356             parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EFirstName) );

   357             }

   358         else

   359             {

   360             parameters->iSenderAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );

   361             parameters->iRecipientAddress->Des().Copy( iEngine->RandomString(CCreatorEngine::EPhoneNumber) );

   362             }

   363 

   364         // subject

   365         parameters->iMessageSubject->Des() = iEngine->RandomString(CCreatorEngine::EMessageSubject);

   366 

   367         // message body

   368         parameters->iMessageBodyText->Des().Copy(_L(""));

   369         TPtrC randText = iEngine->RandomString(CCreatorEngine::EMessageText);

   370         for (TInt i=0; i<parameters->iDefinedMessageLength / randText.Length() +1; i++)

   371             {

   372             parameters->iMessageBodyText->Des().Append( randText );

   373             parameters->iMessageBodyText->Des().Append( _L(" ") );

   374             }

   375         parameters->iMessageBodyText->Des() = parameters->iMessageBodyText->Des().Left(parameters->iDefinedMessageLength);

   376 

   377         // BIO message type (from bitsids.h)  // TO-DO: add support for all BIO message types...

   378         parameters->iBIOMessageType = KUidBIOBusinessCardMsg;

   379         }

   380     

   381     

   382 

   383     TInt err = KErrNone;

   384 

   385     switch (parameters->iMessageType)

   386         {

   387         case ESMS:          { err = CreateSMSEntryL(*parameters);  break; }

   388         case EMMS:          { err = CreateMMSEntryL(*parameters);  break; }

   389         case EAMS:          { err = CreateAMSEntryL(*parameters);  break; }

   390         case EEmail:        { err = CreateEmailEntryL(*parameters);  break; }

   391         case ESmartMessage: { err = CreateSmartMessageEntryL(*parameters);  break; }

   392         case EIrMessage:    { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeIrTInt32), *parameters );  break; }    

   393         case EBTMessage:    { err = CreateObexEntryL( TUid::Uid(KUidMsgTypeBtTInt32), *parameters );  break; }

   394         default:            { User::Panic(_L("MsgType"), 851);  break;}

   395 

   396         }

   397 

   398     iSenderArray.ResetAndDestroy();

   399     iRecipientArray.ResetAndDestroy();

   400     return err;

   401     }

   402 

   403 //----------------------------------------------------------------------------

   404 

   405 TInt CCreatorMessages::CreateSMSEntryL(const CMessagesParameters& parameters)

   406     {

   407     LOGSTRING("Creator: CCreatorMessages::CreateSMSEntryL");

   408 

   409     TInt err = KErrNone;

   410 

   411                

   412     // init

   413     CMsvSession* session = CMsvSession::OpenSyncL(*this);

   414     CleanupStack::PushL(session);

   415     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);

   416     CleanupStack::PushL(registry);

   417 

   418     // get the client mtm and return if it isn't supported in the system        

   419     CSmsClientMtm* clientMtm = NULL;

   420     TRAP(err, clientMtm = static_cast<CSmsClientMtm*>(registry->NewMtmL(KUidMsgTypeSMS)));

   421     if (err || !clientMtm)

   422         {

   423         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Message type module not found"));

   424         CleanupStack::PopAndDestroy(2);

   425         User::Leave(KErrNotFound);

   426         }  

   427     CleanupStack::PushL(clientMtm);   

   428 

   429     // create a new object to access an existing entry

   430     CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

   431     CleanupStack::PushL(msvEntry);

   432   

   433     // get default service

   434     TMsvId defaultServiceId = 0;

   435     TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());

   436     if (err)

   437         {

   438         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("SMS: Define a SMS centre first"));

   439         CleanupStack::PopAndDestroy(2);

   440         User::Leave(KErrNotFound);

   441         } 

   442     

   443     // set folder type

   444     switch (parameters.iFolderType)

   445         {

   446         case EInbox:    { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);   break; }

   447         case EDrafts:   { msvEntry->SetEntryL(KMsvDraftEntryId);              break; }

   448         case EOutbox:   { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);  break; }

   449         case ESent:     { msvEntry->SetEntryL(KMsvSentEntryId);               break; }

   450         default:        { User::Panic(_L("Folder Type"), 871);                break; } 

   451         }

   452         

   453     // mtm takes ownership of entry context	

   454     CleanupStack::Pop(msvEntry);

   455     clientMtm->SetCurrentEntryL(msvEntry);    

   456     

   457     // create a new message

   458     clientMtm->CreateMessageL(defaultServiceId);

   459 

   460     // set the from field to sms header

   461     // !!! This will cause CRASH

   462     /*if (parameters.iFolderType == EInbox)

   463         {

   464         CSmsHeader* smsHeader = &clientMtm->SmsHeader();

   465         delete smsHeader; // <-- This will cause CRASH

   466         smsHeader = NULL;

   467         smsHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, clientMtm->Body());        

   468         if( parameters.iSenderAddress )

   469             {

   470             smsHeader->SetFromAddressL( parameters.iSenderAddress->Des() );

   471             }

   472         else

   473             {

   474             smsHeader->SetFromAddressL(KEmpty);

   475             }

   476         }       */

   477 

   478     // set body

   479     clientMtm->Body().Reset();

   480     clientMtm->Body().InsertL(0, parameters.iMessageBodyText->Des());        

   481 

   482     // get the entry of the message

   483     TMsvEntry messageEntry = clientMtm->Entry().Entry();

   484 

   485     // set the details field

   486     if (parameters.iFolderType == EInbox)

   487         {

   488         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   489         }

   490     else

   491         {

   492         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   493         // Add all recipients to clientMtm

   494         // iRecipientArray is up-to-date so don't call AddRecipientsL here 

   495         for( TInt i = 0; i < iRecipientArray.Count(); i++ )

   496             {

   497             clientMtm->AddAddresseeL( iRecipientArray[i]->Des() );

   498             }

   499         }

   500 

   501     // set the sending state for outbox message

   502     // to avoid SMSMtmUI:15 panic in messages application

   503     if (parameters.iFolderType == EOutbox )

   504         {

   505         messageEntry.SetSendingState( KMsvSendStateWaiting );

   506         }

   507 

   508     // set the description field same as the first part of the message body

   509     messageEntry.iDescription.Set( parameters.iMessageBodyText->Des().Left(KSmsDescriptionLength) );

   510 

   511     // save the changes done above

   512     clientMtm->Entry().ChangeL(messageEntry);

   513 

   514     // save the message     

   515     clientMtm->SaveMessageL();

   516     	

   517 	// final fine tuning

   518     messageEntry.SetAttachment(EFalse);

   519     messageEntry.iDate.HomeTime();

   520     messageEntry.SetVisible(ETrue);

   521     messageEntry.SetInPreparation(EFalse);

   522    

   523     if (parameters.iCreateAsUnread)

   524         {

   525         messageEntry.SetUnread(ETrue);

   526         messageEntry.SetNew(ETrue);

   527         }

   528     else

   529         {

   530         messageEntry.SetUnread(EFalse);

   531         messageEntry.SetNew(EFalse);

   532         }

   533     

   534     messageEntry.SetComplete(ETrue);

   535     messageEntry.iServiceId = defaultServiceId;

   536     messageEntry.iRelatedId = 0;

   537     clientMtm->Entry().ChangeL(messageEntry);

   538 

   539     // id has been generated, store it for being able to delete

   540     // only entries created with Creator

   541     iEntryIds.Append( messageEntry.Id() );

   542     

   543     CleanupStack::PopAndDestroy(3); //session, registry, clientMtm

   544         

   545     return err;

   546 

   547     }

   548 

   549 //----------------------------------------------------------------------------

   550 

   551 TInt CCreatorMessages::CreateMMSEntryL(const CMessagesParameters& parameters)

   552     {

   553     LOGSTRING("Creator: CCreatorMessages::CreateMMSEntryL");

   554 

   555     TInt err = KErrNone;

   556         

   557     // init

   558     CMsvSession* session = CMsvSession::OpenSyncL(*this);

   559     CleanupStack::PushL(session);

   560     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);

   561     CleanupStack::PushL(registry);

   562 

   563     // get the client mtm and return if it isn't supported in the system        

   564     CMmsClientMtm* clientMtm = NULL;

   565     TRAP(err, clientMtm = static_cast<CMmsClientMtm*>(registry->NewMtmL(KUidMsgTypeMultimedia)));

   566     if (err || !clientMtm)

   567         {

   568         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Message type module not found"));

   569         CleanupStack::PopAndDestroy(2);

   570         User::Leave(KErrNotFound);

   571         }  

   572     CleanupStack::PushL(clientMtm);   

   573 

   574     // create a new object to access an existing entry

   575     CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

   576     CleanupStack::PushL(msvEntry);

   577   

   578     // get default service

   579     TMsvId defaultServiceId = 0;

   580     TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());

   581     if (err)

   582         {

   583         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Define MMS settings first"));

   584         CleanupStack::PopAndDestroy(4);

   585         User::Leave(KErrNotFound);

   586         } 

   587     

   588     // set folder type

   589     switch (parameters.iFolderType)

   590         {

   591         case EInbox:    { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);   break; }

   592         case EDrafts:   { msvEntry->SetEntryL(KMsvDraftEntryId);              break; }

   593         case EOutbox:   { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);  break; }

   594         case ESent:     { msvEntry->SetEntryL(KMsvSentEntryId);               break; }

   595         default:        { User::Panic(_L("Folder Type"), 871);                break; } 

   596         }

   597         

   598     // mtm takes ownership of entry context	

   599     CleanupStack::Pop(msvEntry);

   600     clientMtm->SetCurrentEntryL(msvEntry);    

   601     

   602     // create a new message

   603     clientMtm->CreateMessageL(defaultServiceId);

   604 

   605     // set subject

   606     clientMtm->SetSubjectL( parameters.iMessageSubject->Des() );

   607             

   608     // set some mms defaults

   609     clientMtm->SetMessageClass(EMmsClassPersonal);

   610     clientMtm->SetExpiryInterval(86400);

   611     clientMtm->SetDeliveryTimeInterval(3600);

   612     clientMtm->SetMessagePriority(EMmsPriorityLow);

   613     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   614     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   615     clientMtm->SetReadReply(EMmsReadReplyYes);        

   616     

   617     // set the sender / addressee field

   618     if (parameters.iFolderType == EInbox)

   619         {        

   620         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   621         }

   622     

   623     // Add all recipients to clientMtm

   624     AddRecipientsL( *clientMtm, parameters, EFalse );  

   625         

   626     // get an access to the message store

   627     CMsvStore* store = msvEntry->EditStoreL();

   628     CleanupStack::PushL(store);                  

   629    

   630 

   631     // set body as an attachment

   632     CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

   633     CleanupStack::PushL(mimeHeaders);

   634     mimeHeaders->SetContentTypeL( _L8("text") );

   635     mimeHeaders->SetContentSubTypeL( _L8("plain") );

   636     mimeHeaders->SetMimeCharset( KMmsUtf8 );

   637     mimeHeaders->SetSuggestedFilenameL( _L("body.txt") );

   638     

   639     MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

   640     CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred

   641     CleanupStack::PushL(attachmentInfo);

   642     attachmentInfo->SetAttachmentNameL( _L("body.txt") );

   643     attachmentInfo->SetMimeTypeL( _L8("text/plain") );

   644     mimeHeaders->StoreL( *attachmentInfo );

   645     

   646     RFile textFile;

   647 

   648     CAsyncWaiter* waiter = CAsyncWaiter::NewLC();

   649     attachMan.CreateAttachmentL(_L("body.txt"), textFile, attachmentInfo, waiter->iStatus );

   650     CleanupStack::Pop(); // waiter

   651     CleanupStack::Pop(); // attachmentInfo

   652     CleanupStack::PushL(waiter);

   653     waiter->StartAndWait();

   654     CleanupStack::PopAndDestroy(waiter);        

   655    

   656     HBufC8* tempBuf = CnvUtfConverter::ConvertFromUnicodeToUtf8L( parameters.iMessageBodyText->Des() );

   657     CleanupStack::PushL(tempBuf);

   658     textFile.Write( tempBuf->Des() );        

   659     textFile.Close();

   660     CleanupStack::PopAndDestroy(); //tempBuf

   661     

   662     CleanupStack::PopAndDestroy(); //mimeHeaders

   663 

   664     

   665     // get the entry of the message

   666     TMsvEntry messageEntry = clientMtm->Entry().Entry();        

   667     

   668     // set the details field

   669     if (parameters.iFolderType == EInbox)

   670         {

   671         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   672         }

   673     else

   674         {

   675         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   676         }    

   677 

   678     // set the description field same as the message subject

   679     messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );

   680 

   681     // save the changes done above

   682     clientMtm->Entry().ChangeL(messageEntry);        

   683     

   684 

   685       // save the attachments

   686     HandleAttachementsL(parameters, store, err );

   687 //    for (TInt i=0; i<parameters.iAttachments->Count(); i++)

   688 //        {

   689 //        TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );

   690 //

   691 //        TParse parser;

   692 //        parser.Set(sourceFileName, NULL, NULL);

   693 //        TFileName shortFileName = parser.NameAndExt();

   694 //

   695 //        // get the mime type

   696 //        RApaLsSession ls;

   697 //        User::LeaveIfError(ls.Connect());

   698 //        CleanupClosePushL<RApaLsSession>(ls);

   699 //        TUid appUid;

   700 //        TDataType dataType;

   701 //        ls.AppForDocument(sourceFileName, appUid, dataType);

   702 //        CleanupStack::PopAndDestroy(); //ls

   703 //        TPtrC8 mimeType = dataType.Des8();

   704 //        

   705 //        // attachment settings

   706 //        MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

   707 //        CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred

   708 //        attachmentInfo->SetAttachmentNameL( shortFileName );        

   709 //        attachmentInfo->SetMimeTypeL( mimeType );        

   710 //

   711 //        // save

   712 //        CAsyncWaiter* waiter = CAsyncWaiter::NewLC();

   713 //        

   714 //        TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));

   715 //        if (err == KErrNone)

   716 //            waiter->StartAndWait();

   717 //        else

   718 //            LOGSTRING2("Creator: CCreatorMessages::CreateMMSEntryL failed to attach %S", &sourceFileName);

   719 //

   720 //        CleanupStack::PopAndDestroy(waiter);  

   721 //        }

   722 

   723     // save the changes made to the message store

   724     store->CommitL();

   725     CleanupStack::PopAndDestroy(store);   

   726            

   727     

   728     // save the message      

   729     clientMtm->SaveMessageL();

   730     	

   731 	// final fine tuning

   732 	messageEntry.SetAttachment(ETrue);

   733     messageEntry.iDate.HomeTime();

   734     messageEntry.SetVisible(ETrue);

   735     messageEntry.SetInPreparation(EFalse);

   736     if (parameters.iCreateAsUnread)

   737         {

   738         messageEntry.SetUnread(ETrue);

   739         messageEntry.SetNew(ETrue);

   740         }

   741     else

   742         {

   743         messageEntry.SetUnread(EFalse);

   744         messageEntry.SetNew(EFalse);

   745         }

   746     messageEntry.SetComplete(ETrue);

   747     messageEntry.iServiceId = defaultServiceId;

   748     messageEntry.iRelatedId = 0;

   749     

   750     if (parameters.iFolderType == EDrafts) 

   751         messageEntry.SetReadOnly(EFalse);

   752     else

   753         messageEntry.SetReadOnly(ETrue);

   754 

   755 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

   756 	

   757     clientMtm->Entry().ChangeL(messageEntry);

   758     

   759     // id has been generated, store it for being able to delete

   760     // only entries created with Creator

   761     iEntryIds.Append( messageEntry.Id() );

   762     

   763     CleanupStack::PopAndDestroy(3); //session, registry, clientMtm        

   764         

   765 

   766     return err;

   767     }

   768 

   769 //----------------------------------------------------------------------------

   770 void CCreatorMessages::HandleAttachementsL(const CMessagesParameters& parameters, CMsvStore* store, TInt err )

   771     {

   772     // save the attachments (added with id's)

   773   for (TInt i=0; i<parameters.iAttachments->Count(); i++)

   774       {

   775       TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );

   776       HandleAttachementL(store, err, sourceFileName );

   777 

   778       }    

   779   //Adding attachmentpaths

   780   for (TInt i=0; i<parameters.iAttachmentPaths.Count(); i++)

   781       {

   782       HBufC* point = parameters.iAttachmentPaths[i];

   783       TFileName sourceFileName(point->Des());      

   784       HandleAttachementL(store, err, sourceFileName );

   785       }

   786     }

   787 //----------------------------------------------------------------------------

   788 

   789 void CCreatorMessages::HandleAttachementL(CMsvStore* store, TInt err, TFileName& sourceFileName )

   790     {

   791     TParse parser;

   792     parser.Set(sourceFileName, NULL, NULL);

   793     TFileName shortFileName = parser.NameAndExt();

   794 

   795     // get the mime type

   796     RApaLsSession ls;

   797     User::LeaveIfError(ls.Connect());

   798     CleanupClosePushL<RApaLsSession>(ls);

   799     TUid appUid;

   800     TDataType dataType;

   801     ls.AppForDocument(sourceFileName, appUid, dataType);

   802     CleanupStack::PopAndDestroy(); //ls

   803     TPtrC8 mimeType = dataType.Des8();

   804     

   805     // attachment settings

   806     MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

   807     CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred

   808     CleanupStack::PushL(attachmentInfo);

   809     attachmentInfo->SetAttachmentNameL( shortFileName );        

   810     attachmentInfo->SetMimeTypeL( mimeType );

   811     

   812     if ( mimeType == _L8("text/plain") )

   813         {

   814         // CMsvMimeHeaders needs to be stored in case of text file 

   815         CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

   816         CleanupStack::PushL(mimeHeaders);

   817         mimeHeaders->SetContentTypeL( _L8("text") );

   818         mimeHeaders->SetContentSubTypeL( _L8("plain") );

   819         mimeHeaders->SetMimeCharset( KMmsUtf8 );

   820         mimeHeaders->StoreL( *attachmentInfo );

   821         CleanupStack::PopAndDestroy( mimeHeaders );

   822         }

   823 

   824     // save

   825     

   826     CAsyncWaiter* waiter = CAsyncWaiter::NewLC();

   827     TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));

   828     if (err == KErrNone)

   829     	{

   830         waiter->StartAndWait();

   831         CleanupStack::PopAndDestroy(waiter);

   832         CleanupStack::Pop(); // attachmentInfo, the ownership is transferred

   833     	}

   834     else

   835     	{

   836     	CleanupStack::PopAndDestroy(waiter);

   837     	CleanupStack::PopAndDestroy(); // attachmentInfo, ownership is not transferred (leave occurs)

   838         LOGSTRING2("Creator: CCreatorMessages::HandleAttachementsL failed to attach %S", &sourceFileName);

   839     	}

   840     }

   841       //----------------------------------------------------------------------------

   842 

   843 TInt CCreatorMessages::CreateAMSEntryL(const CMessagesParameters& parameters)

   844     {

   845     LOGSTRING("Creator: CCreatorMessages::CreateAMSEntryL");

   846 

   847     TInt err = KErrNone;

   848 

   849         

   850     // init

   851     CMsvSession* session = CMsvSession::OpenSyncL(*this);

   852     CleanupStack::PushL(session);

   853     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);

   854     CleanupStack::PushL(registry);

   855 

   856     // get the client mtm and return if it isn't supported in the system        

   857     CMmsClientMtm* clientMtm = NULL;

   858     TRAP(err, clientMtm = static_cast<CMmsClientMtm*>(registry->NewMtmL(KUidMsgTypeMultimedia)));

   859     if (err || !clientMtm)

   860         {

   861         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Message type module not found"));

   862         CleanupStack::PopAndDestroy(2);

   863         User::Leave(KErrNotFound);

   864         }  

   865     CleanupStack::PushL(clientMtm);   

   866 

   867     // create a new object to access an existing entry

   868     CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

   869     CleanupStack::PushL(msvEntry);

   870   

   871     // get default service

   872     TMsvId defaultServiceId = 0;

   873     TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());

   874     if (err)

   875         {

   876         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("MMS: Define MMS settings first"));

   877         CleanupStack::PopAndDestroy(2);

   878         User::Leave(KErrNotFound);

   879         } 

   880     

   881     // set folder type

   882     switch (parameters.iFolderType)

   883         {

   884         case EInbox:    { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);   break; }

   885         case EDrafts:   { msvEntry->SetEntryL(KMsvDraftEntryId);              break; }

   886         case EOutbox:   { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);  break; }

   887         case ESent:     { msvEntry->SetEntryL(KMsvSentEntryId);               break; }

   888         default:        { User::Panic(_L("Folder Type"), 871);                break; } 

   889         }

   890         

   891     // mtm takes ownership of entry context	

   892     CleanupStack::Pop(msvEntry);

   893     clientMtm->SetCurrentEntryL(msvEntry);    

   894     

   895     // create a new message

   896     clientMtm->CreateMessageL(defaultServiceId);

   897 

   898     // set subject

   899     clientMtm->SetSubjectL(parameters.iMessageSubject->Des() );

   900             

   901     // set some mms defaults

   902     clientMtm->SetMessageClass(EMmsClassPersonal);

   903     clientMtm->SetExpiryInterval(86400);

   904     clientMtm->SetDeliveryTimeInterval(3600);

   905     clientMtm->SetMessagePriority(EMmsPriorityLow);

   906     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   907     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   908     clientMtm->SetReadReply(EMmsReadReplyYes);        

   909     

   910     // set the sender / addressee field

   911     if (parameters.iFolderType == EInbox)

   912         {

   913         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   914         }

   915 

   916     // Add all recipients to clientMtm

   917     AddRecipientsL( *clientMtm, parameters, EFalse );

   918     

   919         

   920     // get an access to the message store

   921     CMsvStore* store = msvEntry->EditStoreL();

   922     CleanupStack::PushL(store);                  

   923    

   924     // get the entry of the message

   925     TMsvEntry messageEntry = clientMtm->Entry().Entry();        

   926     

   927     // set the details field

   928     if (parameters.iFolderType == EInbox)

   929         {

   930         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   931         }  

   932     else

   933         {

   934         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   935         }

   936 

   937     // set the description field same as the message subject

   938     messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );

   939     messageEntry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;

   940     

   941     // save the changes done above

   942     clientMtm->Entry().ChangeL(messageEntry);        

   943     

   944 

   945     TFileName sourceFileName = iEngine->TestDataPathL( CCreatorEngine::EAMR_20kB );

   946     TParse parser;

   947     parser.Set(sourceFileName, NULL, NULL);

   948     TFileName shortFileName = parser.NameAndExt();

   949 

   950     // get the mime type

   951     RApaLsSession ls;

   952     User::LeaveIfError(ls.Connect());

   953     CleanupClosePushL<RApaLsSession>(ls);

   954     TUid appUid;

   955     TDataType dataType;

   956     ls.AppForDocument(sourceFileName, appUid, dataType);

   957     CleanupStack::PopAndDestroy(); //ls

   958     TPtrC8 mimeType = dataType.Des8();

   959         

   960     // attachment settings

   961     MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

   962     CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // ownership of attachmentInfo will be transferred

   963     attachmentInfo->SetAttachmentNameL( shortFileName );        

   964     attachmentInfo->SetMimeTypeL( mimeType );        

   965 

   966     // save

   967     CAsyncWaiter* waiter = CAsyncWaiter::NewLC();

   968       

   969     TRAP(err, attachMan.AddAttachmentL(sourceFileName, attachmentInfo, waiter->iStatus ));

   970     if (err == KErrNone)

   971         waiter->StartAndWait();

   972     else

   973         LOGSTRING2("Creator: CCreatorMessages::CreateAMSEntryL failed to attach %S", &sourceFileName);

   974 

   975     CleanupStack::PopAndDestroy(waiter);  

   976 

   977     // save the changes made to the message store

   978     store->CommitL();

   979     CleanupStack::PopAndDestroy(store);   

   980            

   981     

   982     // save the message      

   983     clientMtm->SaveMessageL();

   984     	

   985 	// final fine tuning

   986 	messageEntry.SetAttachment(ETrue);

   987     messageEntry.iDate.HomeTime();

   988     messageEntry.SetVisible(ETrue);

   989     messageEntry.SetInPreparation(EFalse);

   990     if (parameters.iCreateAsUnread)

   991         {

   992         messageEntry.SetUnread(ETrue);

   993         messageEntry.SetNew(ETrue);

   994         }

   995     else

   996         {

   997         messageEntry.SetUnread(EFalse);

   998         messageEntry.SetNew(EFalse);

   999         }

  1000     messageEntry.SetComplete(ETrue);

  1001     messageEntry.iServiceId = defaultServiceId;

  1002     messageEntry.iRelatedId = 0;

  1003     

  1004     if (parameters.iFolderType == EDrafts) 

  1005         messageEntry.SetReadOnly(EFalse);

  1006     else

  1007         messageEntry.SetReadOnly(ETrue);

  1008 

  1009 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

  1010 	

  1011     clientMtm->Entry().ChangeL(messageEntry);

  1012     

  1013     // id has been generated, store it for being able to delete

  1014     // only entries created with Creator

  1015     iEntryIds.Append( messageEntry.Id() );

  1016     

  1017     CleanupStack::PopAndDestroy(3); //session, registry, clientMtm        

  1018         

  1019 

  1020     return err;

  1021     }

  1022 

  1023 //----------------------------------------------------------------------------

  1024 

  1025 TInt CCreatorMessages::CreateEmailEntryL(const CMessagesParameters& parameters)

  1026     {

  1027     LOGSTRING("Creator: CCreatorMessages::CreateEmailEntryL");

  1028 

  1029     TInt err = KErrNone;

  1030 

  1031     // init

  1032     CMsvSession* session = CMsvSession::OpenSyncL(*this);

  1033     CleanupStack::PushL(session);

  1034     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*session);

  1035     CleanupStack::PushL(registry);

  1036     

  1037     // get the client mtm and return if it isn't supported in the system        

  1038     CSmtpClientMtm* clientMtm = NULL;

  1039     TRAP(err, clientMtm = static_cast<CSmtpClientMtm*>(registry->NewMtmL(KUidMsgTypeSMTP)));

  1040     

  1041     if (err || !clientMtm)

  1042         {

  1043         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("Email: Message type module not found"));

  1044         CleanupStack::PopAndDestroy(2);

  1045         User::Leave(KErrNotFound);

  1046         }  

  1047     CleanupStack::PushL(clientMtm);   

  1048 

  1049     // create a new object to access an existing entry

  1050     CMsvEntry* msvEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

  1051     CleanupStack::PushL(msvEntry);

  1052   

  1053     // get default service

  1054     TMsvId defaultServiceId(0);

  1055     TRAP(err, defaultServiceId = clientMtm->DefaultServiceL());

  1056     if (err)

  1057         {

  1058         iEngine->GetEngineWrapper()->ShowErrorMessage(_L("Email: Define a mailbox first"));

  1059         CleanupStack::PopAndDestroy(2);

  1060         User::Leave(KErrNotFound);

  1061         } 

  1062                 

  1063     // set folder type

  1064     switch (parameters.iFolderType)

  1065         {

  1066         case EInbox:    { msvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);   break; }

  1067         case EDrafts:   { msvEntry->SetEntryL(KMsvDraftEntryId);              break; }

  1068         case EOutbox:   { msvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);  break; }

  1069         case ESent:     { msvEntry->SetEntryL(KMsvSentEntryId);               break; }

  1070         case EMailbox:  { msvEntry->SetEntryL(iUserSelectedMailbox);          break; }

  1071         default:        { User::Panic(_L("Folder Type"), 871);                break; } 

  1072         }

  1073         

  1074     // mtm takes ownership of entry context	

  1075     CleanupStack::Pop(msvEntry);

  1076     clientMtm->SetCurrentEntryL(msvEntry); 

  1077 

  1078     // create a new message

  1079     clientMtm->CreateMessageL(defaultServiceId);

  1080 

  1081     // set subject

  1082     clientMtm->SetSubjectL( parameters.iMessageSubject->Des() );

  1083     

  1084     // set body

  1085     clientMtm->Body().Reset();

  1086     clientMtm->Body().InsertL(0, parameters.iMessageBodyText->Des()); 

  1087 

  1088     // get the entry of the message

  1089     TMsvEntry messageEntry = clientMtm->Entry().Entry();

  1090     

  1091     // set the address fields

  1092     if (parameters.iFolderType == EInbox)

  1093         {

  1094         AddSenderToMtmAddresseeL(*clientMtm, parameters, ETrue );

  1095         SetSenderToEntryDetailsL(messageEntry, parameters, ETrue);

  1096         messageEntry.iMtm = KUidMsgTypeIMAP4;  // or any other than KUidMsgTypeSMTP to display 'from' field instead of 'to' field 

  1097         }

  1098     else

  1099         {

  1100         // Add all recipients to clientMtm

  1101         AddRecipientsL( *clientMtm, parameters, ETrue );

  1102         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);        

  1103         }

  1104 

  1105     // set the description field same as the message subject

  1106     messageEntry.iDescription.Set( parameters.iMessageSubject->Des().Left(KSmsDescriptionLength) );

  1107 

  1108     // save the changes done above

  1109     clientMtm->Entry().ChangeL(messageEntry);

  1110     

  1111     // get an access to the message store

  1112     CMsvStore* store = msvEntry->EditStoreL();

  1113     CleanupStack::PushL(store); 

  1114     

  1115     // save the attachments

  1116     HandleAttachementsL(parameters, store, err);

  1117 //    for (TInt i=0; i<parameters.iAttachments->Count(); i++)

  1118 //        {

  1119 //        TFileName sourceFileName = iEngine->TestDataPathL( (CCreatorEngine::TTestDataPath) parameters.iAttachments->At(i) );

  1120 //

  1121 //        TParse parser;

  1122 //        parser.Set(sourceFileName, NULL, NULL);

  1123 //        TFileName shortFileName = parser.NameAndExt();

  1124 //

  1125 //        // get the mime type

  1126 //        RApaLsSession ls;

  1127 //        User::LeaveIfError(ls.Connect());

  1128 //        CleanupClosePushL<RApaLsSession>(ls);

  1129 //        TUid appUid;

  1130 //        TDataType dataType;

  1131 //        ls.AppForDocument(sourceFileName, appUid, dataType);

  1132 //        CleanupStack::PopAndDestroy(); //ls

  1133 //        TPtrC8 mimeType = dataType.Des8();

  1134 //        

  1135 //        // attachment settings