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 "creator_phonebook.h"

    26 #include <apgcli.h>

    27 #include <MuiuServiceUtilities.h>

    28 #include <utf.h>

    29 

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

    31 

    32 //static const TInt KMessagesFieldLength = 1024;

    33 

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

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

    36 

    37 

    38 const TUid KUidBIOBusinessCardMsg =  {0x10005531}; 

    39 _LIT(KEmpty, "");

    40 

    41 //----------------------------------------------------------------------------

    42 

    43 CMessagesParameters::CMessagesParameters()

    44     {

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

    46 

    47     iSenderAddress = HBufC::New(128);

    48     iRecipientAddress = HBufC::New(128);

    49     iMessageSubject = HBufC::New(128);

    50     iMessageBodyText = HBufC::New(10240);

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

    52     iCreateAsUnread = ETrue;

    53     }

    54 

    55 CMessagesParameters::~CMessagesParameters()

    56     {

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

    58 

    59 

    60     delete iMessageBodyText;

    61     delete iMessageSubject;

    62     delete iRecipientAddress;

    63     delete iSenderAddress;

    64     delete iAttachments;

    65     iAttachmentPaths.ResetAndDestroy();

    66     iAttachmentPaths.Close(); 

    67     iRecipientAddressArray.ResetAndDestroy();

    68     iRecipientAddressArray.Close();

    69     iRecipientLinkIds.Close();

    70     iSenderLinkIds.Close();

    71     }

    72 

    73 //----------------------------------------------------------------------------

    74 

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

    76     {

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

    78     CleanupStack::Pop(self);

    79     return self;

    80     }

    81 

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

    83     {

    84     CCreatorMessages* self = new (ELeave) CCreatorMessages;

    85     CleanupStack::PushL(self);

    86     self->ConstructL(aEngine);

    87     return self;

    88     }

    89 

    90 CCreatorMessages::CCreatorMessages()

    91     {

    92     }

    93 

    94 void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)

    95     {

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

    97     iEngine = aEngine;

    98     

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

   100     iWaiter = CAsyncWaiter::NewL();

   101     }

   102 

   103 CCreatorMessages::~CCreatorMessages()

   104     {

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

   106 

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

   108         {

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

   110         }

   111     iEntryIds.Reset();

   112     iEntryIds.Close();

   113     

   114     delete iParameters;

   115     delete iWaiter;

   116     delete iTmpPhoneNumber;

   117     delete iTmpEmail;

   118     delete iAttachments;

   119 

   120     iRecipientArray.ResetAndDestroy();

   121     iRecipientArray.Close();

   122     iSenderArray.ResetAndDestroy();

   123     iSenderArray.Close();

   124     }

   125 

   126 //----------------------------------------------------------------------------

   127 

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

   129     {

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

   131     

   132     if( aPositiveAction == EFalse )

   133         {

   134         iEngine->ShutDownEnginesL();

   135         return;

   136         }

   137     

   138     const TDesC* showText = &KSavingText;

   139     TBool finished(EFalse);

   140     TBool retval(ETrue);

   141     switch(aUserData)

   142         {

   143         case ECreatorMessagesDelete:

   144             showText = &KDeletingText;

   145             iEntriesToBeCreated = 1;

   146             finished = ETrue;

   147             break;

   148         case ECreatorMessagesStart:

   149             // message type query

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

   151             break;

   152         case ECreatorMessagesMessageType:

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

   154             break;

   155         case ECreatorMessagesFolderType:

   156             // query create as unread

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

   158             break;

   159         case ECreatorMessagesMessageStatus:

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

   161                 {

   162                 iDefinedMessageLength = 100;

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

   164                     this, ECreatorMessagesCharsInBody

   165                     );

   166                 break;

   167                 }

   168             else

   169                 {

   170                 iDefinedMessageLength = 0;

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

   172                 }

   173         case ECreatorMessagesCharsInBody:

   174             // query attachments

   175             iAttachments->Reset();

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

   177                 {

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

   179                     iAttachments, this, ECreatorMessagesAttachment

   180                     );

   181                 }

   182             else if( iMessageType == EAMS )

   183                 {

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

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

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

   187                     );

   188                 }

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

   190                 {

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

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

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

   194                     );

   195                 }

   196             else

   197                 {

   198                 finished = ETrue;

   199                 }

   200             break;

   201         case ECreatorMessagesAttachment:

   202             finished = ETrue;

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

   204                 {

   205                 // "none" is selected

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

   207                     {

   208                     iAttachments->Reset();

   209                     }

   210                 else  // otherwise fix indexes

   211                     {

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

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

   214 

   215                     }

   216                 }

   217             break;

   218         default:

   219             //some error

   220             retval = EFalse;

   221             break;

   222         }

   223     if( retval == EFalse )

   224         {

   225         iEngine->ShutDownEnginesL();

   226         }

   227     else if( finished )

   228         {

   229         // add this command to command array

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

   231         // started exucuting commands

   232         iEngine->ExecuteFirstCommandL( *showText );

   233         }

   234     }

   235 //----------------------------------------------------------------------------

   236 

   237 TBool CCreatorMessages::AskDataFromUserL(TInt aCommand)

   238     {

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

   240 

   241     CCreatorModuleBase::AskDataFromUserL(aCommand);

   242     

   243     if ( aCommand == ECmdDeleteMessages )

   244         {

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

   246         }

   247     else if ( aCommand ==  ECmdDeleteCreatorMessages )

   248         {

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

   250         }

   251 

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

   253     }

   254 

   255 //----------------------------------------------------------------------------

   256 

   257 TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)

   258     {

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

   260 

   261     TInt err = KErrNone;

   262     

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

   264 

   265 

   266     switch (aCommand)

   267         {

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

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

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

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

   272 	    

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

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

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

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

   277 	    

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

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

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

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

   282 	    

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

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

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

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

   287 	    

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

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

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

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

   292 	    

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

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

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

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

   297         

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

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

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

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

   302 

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

   304         }

   305 

   306     return err;

   307     }

   308 

   309 //----------------------------------------------------------------------------

   310 

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

   312     {

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

   314     

   315     delete iParameters;

   316     iParameters = 0;   

   317     

   318     CMessagesParameters* parameters = aParameters;

   319            

   320     // random data needed if no predefined data available

   321     if (!parameters)

   322         {

   323         iParameters = new(ELeave) CMessagesParameters;

   324         parameters = iParameters;

   325         // check if values from ui needed

   326         //if (aTakeUserGivenParameters)

   327         //    {            

   328             parameters->iMessageType = iMessageType;

   329             parameters->iFolderType = iFolderType;

   330             parameters->iDefinedMessageLength = iDefinedMessageLength;

   331             parameters->iCreateAsUnread = iCreateAsUnread;

   332 

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

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

   335         //    }

   336         //else

   337         //    {

   338             // message length

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

   340         //    }    

   341 

   342         if (parameters->iMessageType == EEmail)

   343             {

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

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

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

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

   348 

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

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

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

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

   353             }

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

   355             {

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

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

   358             }

   359         else

   360             {

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

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

   363             }

   364 

   365         // subject

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

   367 

   368         // message body

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

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

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

   372             {

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

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

   375             }

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

   377 

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

   379         parameters->iBIOMessageType = KUidBIOBusinessCardMsg;

   380         }

   381     

   382     

   383 

   384     TInt err = KErrNone;

   385 

   386     switch (parameters->iMessageType)

   387         {

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

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

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

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

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

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

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

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

   396 

   397         }

   398 

   399     iSenderArray.ResetAndDestroy();

   400     iRecipientArray.ResetAndDestroy();

   401     return err;

   402     }

   403 

   404 //----------------------------------------------------------------------------

   405 

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

   407     {

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

   409 

   410     TInt err = KErrNone;

   411 

   412                

   413     // init

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

   415     CleanupStack::PushL(session);

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

   417     CleanupStack::PushL(registry);

   418 

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

   420     CSmsClientMtm* clientMtm = NULL;

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

   422     if (err || !clientMtm)

   423         {

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

   425         CleanupStack::PopAndDestroy(2);

   426         User::Leave(KErrNotFound);

   427         }  

   428     CleanupStack::PushL(clientMtm);   

   429 

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

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

   432     CleanupStack::PushL(msvEntry);

   433   

   434     // get default service

   435     TMsvId defaultServiceId = 0;

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

   437     if (err)

   438         {

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

   440         CleanupStack::PopAndDestroy(2);

   441         User::Leave(KErrNotFound);

   442         } 

   443     

   444     // set folder type

   445     switch (parameters.iFolderType)

   446         {

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

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

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

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

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

   452         }

   453         

   454     // mtm takes ownership of entry context	

   455     CleanupStack::Pop(msvEntry);

   456     clientMtm->SetCurrentEntryL(msvEntry);    

   457     

   458     // create a new message

   459     clientMtm->CreateMessageL(defaultServiceId);

   460 

   461     // set the from field to sms header

   462     // !!! This will cause CRASH

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

   464         {

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

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

   467         smsHeader = NULL;

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

   469         if( parameters.iSenderAddress )

   470             {

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

   472             }

   473         else

   474             {

   475             smsHeader->SetFromAddressL(KEmpty);

   476             }

   477         }       */

   478 

   479     // set body

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

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

   482 

   483     // get the entry of the message

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

   485 

   486     // set the details field

   487     if (parameters.iFolderType == EInbox)

   488         {

   489         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   490         }

   491     else

   492         {

   493         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   494         // Add all recipients to clientMtm

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

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

   497             {

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

   499             }

   500         }

   501 

   502     // set the sending state for outbox message

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

   504     if (parameters.iFolderType == EOutbox )

   505         {

   506         messageEntry.SetSendingState( KMsvSendStateWaiting );

   507         }

   508 

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

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

   511 

   512     // save the changes done above

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

   514 

   515     // save the message     

   516     clientMtm->SaveMessageL();

   517     	

   518 	// final fine tuning

   519     messageEntry.SetAttachment(EFalse);

   520     messageEntry.iDate.HomeTime();

   521     messageEntry.SetVisible(ETrue);

   522     messageEntry.SetInPreparation(EFalse);

   523    

   524     if (parameters.iCreateAsUnread)

   525         {

   526         messageEntry.SetUnread(ETrue);

   527         messageEntry.SetNew(ETrue);

   528         }

   529     else

   530         {

   531         messageEntry.SetUnread(EFalse);

   532         messageEntry.SetNew(EFalse);

   533         }

   534     

   535     messageEntry.SetComplete(ETrue);

   536     messageEntry.iServiceId = defaultServiceId;

   537     messageEntry.iRelatedId = 0;

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

   539 

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

   541     // only entries created with Creator

   542     iEntryIds.AppendL( messageEntry.Id() );

   543     

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

   545         

   546     return err;

   547 

   548     }

   549 

   550 //----------------------------------------------------------------------------

   551 

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

   553     {

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

   555 

   556     TInt err = KErrNone;

   557         

   558     // init

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

   560     CleanupStack::PushL(session);

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

   562     CleanupStack::PushL(registry);

   563 

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

   565     CMmsClientMtm* clientMtm = NULL;

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

   567     if (err || !clientMtm)

   568         {

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

   570         CleanupStack::PopAndDestroy(2);

   571         User::Leave(KErrNotFound);

   572         }  

   573     CleanupStack::PushL(clientMtm);   

   574 

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

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

   577     CleanupStack::PushL(msvEntry);

   578   

   579     // get default service

   580     TMsvId defaultServiceId = 0;

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

   582     if (err)

   583         {

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

   585         CleanupStack::PopAndDestroy(4);

   586         User::Leave(KErrNotFound);

   587         } 

   588     

   589     // set folder type

   590     switch (parameters.iFolderType)

   591         {

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

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

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

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

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

   597         }

   598         

   599     // mtm takes ownership of entry context	

   600     CleanupStack::Pop(msvEntry);

   601     clientMtm->SetCurrentEntryL(msvEntry);    

   602     

   603     // create a new message

   604     clientMtm->CreateMessageL(defaultServiceId);

   605 

   606     // set subject

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

   608             

   609     // set some mms defaults

   610     clientMtm->SetMessageClass(EMmsClassPersonal);

   611     clientMtm->SetExpiryInterval(86400);

   612     clientMtm->SetDeliveryTimeInterval(3600);

   613     clientMtm->SetMessagePriority(EMmsPriorityLow);

   614     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   615     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   616     clientMtm->SetReadReply(EMmsReadReplyYes);        

   617     

   618     // set the sender / addressee field

   619     if (parameters.iFolderType == EInbox)

   620         {        

   621         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   622         }

   623     

   624     // Add all recipients to clientMtm

   625     AddRecipientsL( *clientMtm, parameters, EFalse );  

   626         

   627     // get an access to the message store

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

   629     CleanupStack::PushL(store);                  

   630    

   631 

   632     // set body as an attachment

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

   634     CleanupStack::PushL(mimeHeaders);

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

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

   637     mimeHeaders->SetMimeCharset( KMmsUtf8 );

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

   639     

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

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

   642     CleanupStack::PushL(attachmentInfo);

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

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

   645     mimeHeaders->StoreL( *attachmentInfo );

   646     

   647     RFile textFile;

   648 

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

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

   651     CleanupStack::Pop(); // waiter

   652     CleanupStack::Pop(); // attachmentInfo

   653     CleanupStack::PushL(waiter);

   654     waiter->StartAndWait();

   655     CleanupStack::PopAndDestroy(waiter);        

   656    

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

   658     CleanupStack::PushL(tempBuf);

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

   660     textFile.Close();

   661     CleanupStack::PopAndDestroy(); //tempBuf

   662     

   663     CleanupStack::PopAndDestroy(); //mimeHeaders

   664 

   665     

   666     // get the entry of the message

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

   668     

   669     // set the details field

   670     if (parameters.iFolderType == EInbox)

   671         {

   672         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   673         }

   674     else

   675         {

   676         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   677         }    

   678 

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

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

   681 

   682     // save the changes done above

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

   684     

   685 

   686       // save the attachments

   687     HandleAttachementsL(parameters, store, err );

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

   689 //        {

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

   691 //

   692 //        TParse parser;

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

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

   695 //

   696 //        // get the mime type

   697 //        RApaLsSession ls;

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

   699 //        CleanupClosePushL<RApaLsSession>(ls);

   700 //        TUid appUid;

   701 //        TDataType dataType;

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

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

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

   705 //        

   706 //        // attachment settings

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

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

   709 //        attachmentInfo->SetAttachmentNameL( shortFileName );        

   710 //        attachmentInfo->SetMimeTypeL( mimeType );        

   711 //

   712 //        // save

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

   714 //        

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

   716 //        if (err == KErrNone)

   717 //            waiter->StartAndWait();

   718 //        else

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

   720 //

   721 //        CleanupStack::PopAndDestroy(waiter);  

   722 //        }

   723 

   724     // save the changes made to the message store

   725     store->CommitL();

   726     CleanupStack::PopAndDestroy(store);   

   727            

   728     

   729     // save the message      

   730     clientMtm->SaveMessageL();

   731     	

   732 	// final fine tuning

   733 	messageEntry.SetAttachment(ETrue);

   734     messageEntry.iDate.HomeTime();

   735     messageEntry.SetVisible(ETrue);

   736     messageEntry.SetInPreparation(EFalse);

   737     if (parameters.iCreateAsUnread)

   738         {

   739         messageEntry.SetUnread(ETrue);

   740         messageEntry.SetNew(ETrue);

   741         }

   742     else

   743         {

   744         messageEntry.SetUnread(EFalse);

   745         messageEntry.SetNew(EFalse);

   746         }

   747     messageEntry.SetComplete(ETrue);

   748     messageEntry.iServiceId = defaultServiceId;

   749     messageEntry.iRelatedId = 0;

   750     

   751     if (parameters.iFolderType == EDrafts) 

   752         messageEntry.SetReadOnly(EFalse);

   753     else

   754         messageEntry.SetReadOnly(ETrue);

   755 

   756 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

   757 	

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

   759     

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

   761     // only entries created with Creator

   762     iEntryIds.AppendL( messageEntry.Id() );

   763     

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

   765         

   766 

   767     return err;

   768     }

   769 

   770 //----------------------------------------------------------------------------

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

   772     {

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

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

   775       {

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

   777       HandleAttachementL(store, err, sourceFileName );

   778 

   779       }    

   780   //Adding attachmentpaths

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

   782       {

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

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

   785       HandleAttachementL(store, err, sourceFileName );

   786       }

   787     }

   788 //----------------------------------------------------------------------------

   789 

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

   791     {

   792     TParse parser;

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

   794     TFileName shortFileName = parser.NameAndExt();

   795 

   796     // get the mime type

   797     RApaLsSession ls;

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

   799     CleanupClosePushL<RApaLsSession>(ls);

   800     TUid appUid;

   801     TDataType dataType;

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

   803     CleanupStack::PopAndDestroy(); //ls

   804     TPtrC8 mimeType = dataType.Des8();

   805     

   806     // attachment settings

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

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

   809     CleanupStack::PushL(attachmentInfo);

   810     attachmentInfo->SetAttachmentNameL( shortFileName );        

   811     attachmentInfo->SetMimeTypeL( mimeType );

   812     

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

   814         {

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

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

   817         CleanupStack::PushL(mimeHeaders);

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

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

   820         mimeHeaders->SetMimeCharset( KMmsUtf8 );

   821         mimeHeaders->StoreL( *attachmentInfo );

   822         CleanupStack::PopAndDestroy( mimeHeaders );

   823         }

   824 

   825     // save

   826     

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

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

   829     if (err == KErrNone)

   830     	{

   831         waiter->StartAndWait();

   832         CleanupStack::PopAndDestroy(waiter);

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

   834     	}

   835     else

   836     	{

   837     	CleanupStack::PopAndDestroy(waiter);

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

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

   840     	}

   841     }

   842       //----------------------------------------------------------------------------

   843 

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

   845     {

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

   847 

   848     TInt err = KErrNone;

   849 

   850         

   851     // init

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

   853     CleanupStack::PushL(session);

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

   855     CleanupStack::PushL(registry);

   856 

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

   858     CMmsClientMtm* clientMtm = NULL;

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

   860     if (err || !clientMtm)

   861         {

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

   863         CleanupStack::PopAndDestroy(2);

   864         User::Leave(KErrNotFound);

   865         }  

   866     CleanupStack::PushL(clientMtm);   

   867 

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

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

   870     CleanupStack::PushL(msvEntry);

   871   

   872     // get default service

   873     TMsvId defaultServiceId = 0;

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

   875     if (err)

   876         {

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

   878         CleanupStack::PopAndDestroy(2);

   879         User::Leave(KErrNotFound);

   880         } 

   881     

   882     // set folder type

   883     switch (parameters.iFolderType)

   884         {

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

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

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

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

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

   890         }

   891         

   892     // mtm takes ownership of entry context	

   893     CleanupStack::Pop(msvEntry);

   894     clientMtm->SetCurrentEntryL(msvEntry);    

   895     

   896     // create a new message

   897     clientMtm->CreateMessageL(defaultServiceId);

   898 

   899     // set subject

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

   901             

   902     // set some mms defaults

   903     clientMtm->SetMessageClass(EMmsClassPersonal);

   904     clientMtm->SetExpiryInterval(86400);

   905     clientMtm->SetDeliveryTimeInterval(3600);

   906     clientMtm->SetMessagePriority(EMmsPriorityLow);

   907     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   908     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   909     clientMtm->SetReadReply(EMmsReadReplyYes);        

   910     

   911     // set the sender / addressee field

   912     if (parameters.iFolderType == EInbox)

   913         {

   914         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   915         }

   916 

   917     // Add all recipients to clientMtm

   918     AddRecipientsL( *clientMtm, parameters, EFalse );

   919     

   920         

   921     // get an access to the message store

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

   923     CleanupStack::PushL(store);                  

   924    

   925     // get the entry of the message

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

   927     

   928     // set the details field

   929     if (parameters.iFolderType == EInbox)

   930         {

   931         SetSenderToEntryDetailsL(messageEntry, parameters, EFalse);        

   932         }  

   933     else

   934         {

   935         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);

   936         }

   937 

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

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

   940     messageEntry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;

   941     

   942     // save the changes done above

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

   944     

   945 

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

   947     TParse parser;

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

   949     TFileName shortFileName = parser.NameAndExt();

   950 

   951     // get the mime type

   952     RApaLsSession ls;

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

   954     CleanupClosePushL<RApaLsSession>(ls);

   955     TUid appUid;

   956     TDataType dataType;

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

   958     CleanupStack::PopAndDestroy(); //ls

   959     TPtrC8 mimeType = dataType.Des8();

   960         

   961     // attachment settings

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

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

   964     attachmentInfo->SetAttachmentNameL( shortFileName );        

   965     attachmentInfo->SetMimeTypeL( mimeType );        

   966 

   967     // save

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

   969       

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

   971     if (err == KErrNone)

   972         waiter->StartAndWait();

   973     else

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

   975 

   976     CleanupStack::PopAndDestroy(waiter);  

   977 

   978     // save the changes made to the message store

   979     store->CommitL();

   980     CleanupStack::PopAndDestroy(store);   

   981            

   982     

   983     // save the message      

   984     clientMtm->SaveMessageL();

   985     	

   986 	// final fine tuning

   987 	messageEntry.SetAttachment(ETrue);

   988     messageEntry.iDate.HomeTime();

   989     messageEntry.SetVisible(ETrue);

   990     messageEntry.SetInPreparation(EFalse);

   991     if (parameters.iCreateAsUnread)

   992         {

   993         messageEntry.SetUnread(ETrue);

   994         messageEntry.SetNew(ETrue);

   995         }

   996     else

   997         {

   998         messageEntry.SetUnread(EFalse);

   999         messageEntry.SetNew(EFalse);

  1000         }

  1001     messageEntry.SetComplete(ETrue);

  1002     messageEntry.iServiceId = defaultServiceId;

  1003     messageEntry.iRelatedId = 0;

  1004     

  1005     if (parameters.iFolderType == EDrafts) 

  1006         messageEntry.SetReadOnly(EFalse);

  1007     else

  1008         messageEntry.SetReadOnly(ETrue);

  1009 

  1010 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

  1011 	

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

  1013     

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

  1015     // only entries created with Creator

  1016     iEntryIds.AppendL( messageEntry.Id() );

  1017     

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

  1019         

  1020 

  1021     return err;

  1022     }

  1023 

  1024 //----------------------------------------------------------------------------

  1025 

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

  1027     {

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

  1029 

  1030     TInt err = KErrNone;

  1031 

  1032     // init

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

  1034     CleanupStack::PushL(session);

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

  1036     CleanupStack::PushL(registry);

  1037     

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

  1039     CSmtpClientMtm* clientMtm = NULL;

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

  1041     

  1042     if (err || !clientMtm)

  1043         {

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

  1045         CleanupStack::PopAndDestroy(2);

  1046         User::Leave(KErrNotFound);

  1047         }  

  1048     CleanupStack::PushL(clientMtm);   

  1049 

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

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

  1052     CleanupStack::PushL(msvEntry);

  1053   

  1054     // get default service

  1055     TMsvId defaultServiceId(0);

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

  1057     if (err)

  1058         {

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

  1060         CleanupStack::PopAndDestroy(2);

  1061         User::Leave(KErrNotFound);

  1062         } 

  1063                 

  1064     // set folder type

  1065     switch (parameters.iFolderType)

  1066         {

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

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

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

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

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

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

  1073         }

  1074         

  1075     // mtm takes ownership of entry context	

  1076     CleanupStack::Pop(msvEntry);

  1077     clientMtm->SetCurrentEntryL(msvEntry); 

  1078 

  1079     // create a new message

  1080     clientMtm->CreateMessageL(defaultServiceId);

  1081 

  1082     // set subject

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

  1084     

  1085     // set body

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

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

  1088 

  1089     // get the entry of the message

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

  1091     

  1092     // set the address fields

  1093     if (parameters.iFolderType == EInbox)

  1094         {

  1095         AddSenderToMtmAddresseeL(*clientMtm, parameters, ETrue );

  1096         SetSenderToEntryDetailsL(messageEntry, parameters, ETrue);

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

  1098         }

  1099     else

  1100         {

  1101         // Add all recipients to clientMtm

  1102         AddRecipientsL( *clientMtm, parameters, ETrue );

  1103         SetRecipientToEntryDetailsL(messageEntry, parameters, EFalse);        

  1104         }

  1105 

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

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

  1108 

  1109     // save the changes done above

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

  1111     

  1112     // get an access to the message store

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

  1114     CleanupStack::PushL(store); 

  1115     

  1116     // save the attachments

  1117     HandleAttachementsL(parameters, store, err);

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

  1119 //        {

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

  1121 //

  1122 //        TParse parser;

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

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

  1125 //

  1126 //        // get the mime type

  1127 //        RApaLsSession ls;

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

  1129 //        CleanupClosePushL<RApaLsSession>(ls);

  1130 //        TUid appUid;

  1131 //        TDataType dataType;

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

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

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