1 /*

     2 * Copyright (c) 2008 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 

    20 #include "creator_message.h" 

    21 #include "creator_traces.h"

    22 #include "creator_contactsetcache.h"

    23 #include <apgcli.h>

    24 #include <MuiuMsvUiServiceUtilities.h>

    25 

    26 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

    27 #include <MVPbkFieldType.h>

    28 #include <MVPbkContactOperationBase.h>

    29 #include <MVPbkStoreContactFieldCollection.h>

    30 #include <MVPbkContactFieldTextData.h>

    31 #include <CVPbkContactManager.h>

    32 #include <MVPbkStoreContact.h>

    33 

    34 #include <CVPbkContactStoreUriArray.h>

    35 #include <TVPbkContactStoreUriPtr.h>

    36 #include <VPbkContactStoreUris.h>

    37 #include <MVPbkContactStoreList.h>

    38 #include <MVPbkContactStore.h>

    39 #include <MVPbkContactStoreProperties.h>

    40 #include <VPbkEng.rsg>

    41 #include <cmsvrecipientlist.h>

    42 #endif

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

    44 

    45 

    46 //static const TInt KMessagesFieldLength = 1024;

    47 

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

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

    50 

    51 

    52 const TUid KUidBIOBusinessCardMsg =  {0x10005531}; 

    53 _LIT(KEmpty, "");

    54 

    55 //----------------------------------------------------------------------------

    56 

    57 CMessagesParameters::CMessagesParameters()

    58     {

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

    60 

    61     iSenderAddress = HBufC::New(128);

    62     iRecipientAddress = HBufC::New(128);

    63     iMessageSubject = HBufC::New(128);

    64     iMessageBodyText = HBufC::New(10240);

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

    66     iCreateAsUnread = ETrue;

    67     }

    68 

    69 CMessagesParameters::~CMessagesParameters()

    70     {

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

    72 

    73 

    74     delete iMessageBodyText;

    75     delete iMessageSubject;

    76     delete iRecipientAddress;

    77     delete iSenderAddress;

    78     delete iAttachments;

    79     iAttachmentPaths.ResetAndDestroy();

    80     iAttachmentPaths.Close(); 

    81     iRecipientAddressArray.ResetAndDestroy();

    82     iRecipientAddressArray.Close();

    83     iRecipientLinkIds.Close();

    84     iSenderLinkIds.Close();

    85     }

    86 

    87 //----------------------------------------------------------------------------

    88 

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

    90     {

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

    92     CleanupStack::Pop(self);

    93     return self;

    94     }

    95 

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

    97     {

    98     CCreatorMessages* self = new (ELeave) CCreatorMessages;

    99     CleanupStack::PushL(self);

   100     self->ConstructL(aEngine);

   101     return self;

   102     }

   103 

   104 CCreatorMessages::CCreatorMessages()

   105 :

   106 iSession(0)

   107     {

   108     }

   109 

   110 void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)

   111     {

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

   113     iEngine = aEngine;

   114     

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

   116     iWaiter = CAsyncWaiter::NewL();

   117     }

   118 

   119 CCreatorMessages::~CCreatorMessages()

   120     {

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

   122 

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

   124         {

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

   126         }

   127     iEntryIds.Reset();

   128     iEntryIds.Close();

   129     

   130     delete iParameters;

   131     delete iWaiter;

   132     delete iTmpPhoneNumber;

   133     delete iTmpEmail;

   134     delete iAttachments;

   135 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

   136     delete iExistingContacts;

   137     if( iContactManager )

   138     	iContactManager->ContactStoresL().CloseAll(*this);

   139     delete iContactManager;

   140     delete iTempContact;

   141 #endif

   142     iRecipientArray.ResetAndDestroy();

   143     iRecipientArray.Close();

   144     iSenderArray.ResetAndDestroy();

   145     iSenderArray.Close();

   146     delete iSession;

   147     }

   148 

   149 //----------------------------------------------------------------------------

   150 

   151 TBool CCreatorMessages::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries)

   152     {

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

   154 

   155     if ( aCommand == ECmdDeleteMessages )

   156         {

   157         return iEngine->YesNoQueryDialogL( _L("Delete all messages?") );

   158         }

   159     else if ( aCommand ==  ECmdDeleteCreatorMessages )

   160         {

   161         return iEngine->YesNoQueryDialogL( _L("Delete all messages created with Creator?") );

   162         }

   163 

   164     if (iEngine->EntriesQueryDialogL(aNumberOfEntries, _L("How many entries to create?")))

   165         {

   166         

   167         // message type query

   168         CAknListQueryDialog* dlg1 = new(ELeave) CAknListQueryDialog( (TInt*) &iMessageType );

   169         if (dlg1->ExecuteLD(R_MESSAGE_TYPE_QUERY))

   170             {

   171             TInt folderTypeQueryResource(R_FOLDER_TYPE_QUERY);

   172             

   173             /*

   174             if (iMessageType == EEmail)

   175                 folderTypeQueryResource = R_FOLDER_TYPE_WITH_MAILBOX_QUERY;

   176             */

   177 

   178             // folder query

   179             CAknListQueryDialog* dlg2 = new(ELeave) CAknListQueryDialog( (TInt*) &iFolderType );

   180             if (dlg2->ExecuteLD(folderTypeQueryResource))

   181                 {

   182                 /*

   183                 if (iFolderType == EMailbox)

   184                     {

   185                     // array to hold mailbox names

   186                     CDesCArray* names = new (ELeave) CDesCArrayFlat(16);

   187                     CleanupStack::PushL(names);                    

   188                     

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

   190                     CleanupStack::PushL(session);

   191     

   192                     // generate list of mailboxes

   193                     CMsvEntrySelection* entrySelection = MsvUiServiceUtilities::GetListOfAccountsWithMTML(*session, KUidMsgTypeSMTP, ETrue);

   194                     CleanupStack::PushL(entrySelection);

   195 

   196                     TBool doReturn(EFalse);

   197                     

   198                     if (entrySelection->Count() == 0)

   199                         {

   200                         CAknInformationNote* note = new(ELeave) CAknInformationNote;

   201                         note->ExecuteLD(_L("No mailboxes found"));

   202 

   203                         doReturn = ETrue;

   204                         }

   205                     else

   206                         {

   207                         // get mailbox names

   208                         for (TInt i=0; i<entrySelection->Count(); i++)

   209                             {

   210                             CMsvEntry* centry = session->GetEntryL(entrySelection->At(i));

   211                             CleanupStack::PushL(centry);

   212 

   213                             TMsvEntry tentry = centry->Entry();

   214                             names->AppendL(tentry.iDetails);

   215                             CleanupStack::PopAndDestroy(); //centry

   216                             }

   217                         

   218                         // show query

   219                         TInt index(0);

   220                         CAknListQueryDialog* dlg = new(ELeave) CAknListQueryDialog(&index);

   221                         dlg->PrepareLC(R_MAILBOX_SELECTION_QUERY);

   222                         dlg->SetItemTextArray(names);

   223                         dlg->SetOwnershipType(ELbmDoesNotOwnItemArray);

   224 

   225                         if(dlg->RunLD())

   226                             {

   227                             iUserSelectedMailbox = entrySelection->At(index);

   228 

   229                             doReturn = EFalse;

   230                             }

   231                         else

   232                             {

   233                             doReturn = ETrue;

   234                             }    

   235                         

   236                         }

   237                     

   238                     CleanupStack::PopAndDestroy(3); // names, session, entrySelection

   239                     

   240                     if (doReturn)

   241                         return EFalse;                    

   242                     }

   243                 */

   244                 

   245                 // query create as unread

   246                 CAknListQueryDialog* dlg3 = new(ELeave) CAknListQueryDialog( (TInt*) &iCreateAsUnread );

   247                 if (dlg3->ExecuteLD(R_UNREAD_QUERY))

   248                     {                

   249 

   250                     // query number of characters in msg body

   251                     switch (iMessageType)

   252                         {

   253                         case ESMS:

   254                         case EMMS:

   255                         case EEmail:

   256                             {

   257                             iDefinedMessageLength = 100;

   258                             if (iEngine->EntriesQueryDialogL(iDefinedMessageLength, _L("Amount of characters in message body?"), ETrue))

   259                                 {

   260                                 ;

   261                                 }

   262                             else

   263                                 return EFalse;

   264 

   265                             break;

   266                             }

   267                         case EAMS:

   268                         	{

   269                         	iDefinedMessageLength = 0;

   270                         	break;

   271                         	}

   272                         default: break;

   273                         }

   274 

   275                     // query attachments

   276                     iAttachments->Reset();

   277               

   278                     switch (iMessageType)

   279                         {

   280                         case EMMS:

   281                         case EEmail:

   282                             {

   283                             CAknListQueryDialog* dlg4 = new(ELeave) CAknListQueryDialog( iAttachments );

   284                             if (dlg4->ExecuteLD(R_ATTACHMENT_MULTI_SELECTION_QUERY))

   285                                 {

   286                                 // "none" is selected

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

   288                                     iAttachments->Reset();

   289                                 else  // otherwise fix indexes

   290                                     {

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

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

   293 

   294                                     }

   295                                 }

   296                             else

   297                                 return EFalse;

   298                             

   299                             break;

   300                             }

   301                         case EAMS:

   302                         	{

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

   304 

   305                             CAknListQueryDialog* dlg5 = new(ELeave) CAknListQueryDialog( &iAttachments->At(0) );

   306                             if (dlg5->ExecuteLD(R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY))

   307                                 {

   308                                 ;

   309                                 }

   310                             else

   311                                 return EFalse;                        

   312 

   313                             break;

   314                         	}

   315                             

   316                         case EIrMessage:

   317                         case EBTMessage:

   318                             {

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

   320 

   321                             CAknListQueryDialog* dlg5 = new(ELeave) CAknListQueryDialog( &iAttachments->At(0) );

   322                             if (dlg5->ExecuteLD(R_ATTACHMENT_SINGLE_SELECTION_QUERY))

   323                                 {

   324                                 ;

   325                                 }

   326                             else

   327                                 return EFalse;                        

   328 

   329                             break;

   330                             }

   331                         default: break;

   332                         }

   333                     

   334                     return ETrue;  // all queries accepted

   335 

   336                     }

   337                 else

   338                     return EFalse;

   339                 }

   340             else

   341                 return EFalse;

   342             }

   343         else

   344             return EFalse;

   345         }

   346     else

   347         return EFalse;

   348     }

   349 

   350 //----------------------------------------------------------------------------

   351 

   352 TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)

   353     {

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

   355 

   356     TInt err = KErrNone;

   357     

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

   359 

   360 

   361     switch (aCommand)

   362         {

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

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

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

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

   367 	    

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

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

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

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

   372 	    

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

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

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

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

   377 	    

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

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

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

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

   382 	    

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

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

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

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

   387 	    

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

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

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

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

   392         

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

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

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

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

   397 

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

   399         }

   400 

   401     return err;

   402     }

   403 

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

   405 

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

   407     {

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

   409     

   410     delete iParameters;

   411     iParameters = 0;   

   412     

   413     CMessagesParameters* parameters = aParameters;

   414            

   415     // random data needed if no predefined data available

   416     if (!parameters)

   417         {

   418         iParameters = new(ELeave) CMessagesParameters;

   419         parameters = iParameters;

   420         // check if values from ui needed

   421         //if (aTakeUserGivenParameters)

   422         //    {            

   423             parameters->iMessageType = iMessageType;

   424             parameters->iFolderType = iFolderType;

   425             parameters->iDefinedMessageLength = iDefinedMessageLength;

   426             parameters->iCreateAsUnread = iCreateAsUnread;

   427 

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

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

   430         //    }

   431         //else

   432         //    {

   433             // message length

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

   435         //    }    

   436 

   437         if (parameters->iMessageType == EEmail)

   438             {

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

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

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

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

   443 

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

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

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

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

   448             }

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

   450             {

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

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

   453             }

   454         else

   455             {

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

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

   458             }

   459 

   460         // subject

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

   462 

   463         // message body

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

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

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

   467             {

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

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

   470             }

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

   472 

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

   474         parameters->iBIOMessageType = KUidBIOBusinessCardMsg;

   475         }

   476     

   477     

   478 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

   479     

   480     // Get number of existing senders and recipients:

   481     for( TInt i = 0; i < parameters->iRecipientLinkIds.Count(); ++i )

   482         {       

   483         

   484         TLinkIdParam recipientId = parameters->iRecipientLinkIds[i];        

   485         // Is maximum number limited:

   486         if(recipientId.iLinkAmount == KUndef || 

   487            recipientId.iLinkAmount >= ContactLinkCache::Instance()->ContactSet(recipientId.iLinkId).NumberOfExistingContacts() )

   488             {

   489             parameters->iNumberOfExistingRecipients += ContactLinkCache::Instance()->ContactSet(recipientId.iLinkId).NumberOfExistingContacts();

   490             }

   491         else

   492             {

   493             parameters->iNumberOfExistingRecipients += recipientId.iLinkAmount;

   494             }

   495         }

   496     for( TInt i = 0; i < parameters->iSenderLinkIds.Count(); ++i )

   497         {

   498         TLinkIdParam senderId = parameters->iSenderLinkIds[i];

   499         // Is maximum number limited:

   500         if( senderId.iLinkAmount == KUndef ||

   501             senderId.iLinkAmount >= ContactLinkCache::Instance()->ContactSet(senderId.iLinkId).NumberOfExistingContacts())

   502             {

   503             parameters->iNumberOfExistingSenders += ContactLinkCache::Instance()->ContactSet(senderId.iLinkId).NumberOfExistingContacts();

   504             }

   505         else

   506             {

   507             parameters->iNumberOfExistingSenders += senderId.iLinkAmount;

   508             }            

   509         }

   510     

   511 #endif

   512 

   513     TInt err = KErrNone;

   514 

   515     switch (parameters->iMessageType)

   516         {

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

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

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

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

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

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

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

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

   525 

   526         }

   527 

   528     iSenderArray.ResetAndDestroy();

   529     iRecipientArray.ResetAndDestroy();

   530     return err;

   531     }

   532 

   533 //----------------------------------------------------------------------------

   534 

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

   536     {

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

   538 

   539     TInt err = KErrNone;

   540                

   541     // init    

   542     if( iSession == 0 )

   543         {

   544         iSession = CMsvSession::OpenSyncL(*this);

   545         }

   546 

   547     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*iSession);

   548     CleanupStack::PushL(registry);

   549 

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

   551     CSmsClientMtm* clientMtm = NULL;

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

   553     if (err || !clientMtm)

   554         {

   555         CAknErrorNote* note = new(ELeave) CAknErrorNote;

   556         note->ExecuteLD(_L("SMS: Message type module not found"));

   557         CleanupStack::PopAndDestroy(2);

   558         User::Leave(KErrNotFound);

   559         }  

   560     CleanupStack::PushL(clientMtm);   

   561 

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

   563     CMsvEntry* msvEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

   564     CleanupStack::PushL(msvEntry);

   565   

   566     // get default service

   567     TMsvId defaultServiceId = 0;

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

   569     if (err)

   570         {

   571         CAknErrorNote* note = new(ELeave) CAknErrorNote;

   572         note->ExecuteLD(_L("SMS: Define a SMS centre first"));

   573         CleanupStack::PopAndDestroy(2);

   574         User::Leave(KErrNotFound);

   575         } 

   576     

   577     // set folder type

   578     switch (parameters.iFolderType)

   579         {

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

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

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

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

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

   585         }

   586         

   587     // mtm takes ownership of entry context	

   588     CleanupStack::Pop(msvEntry);

   589     clientMtm->SetCurrentEntryL(msvEntry);    

   590     

   591     // create a new message

   592     clientMtm->CreateMessageL(defaultServiceId);

   593 

   594     // set the from field to sms header

   595     if (parameters.iFolderType == EInbox)

   596         {

   597         CSmsHeader& smsHeader = clientMtm->SmsHeader();

   598 

   599         if( parameters.iSenderAddress )

   600             {

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

   602             }

   603         else

   604             {

   605             smsHeader.SetFromAddressL(KEmpty);

   606             }

   607         }       

   608 

   609     // set body

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

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

   612 

   613     // get the entry of the message

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

   615 

   616     // set the details field

   617     if (parameters.iFolderType == EInbox)

   618         {

   619         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

   620         }

   621     else

   622         {

   623         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

   624         // Add all recipients to clientMtm

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

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

   627             {

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

   629             }

   630         }

   631 

   632     // set the sending state for outbox message

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

   634     if (parameters.iFolderType == EOutbox )

   635         {

   636         messageEntry.SetSendingState( KMsvSendStateWaiting );

   637         }

   638 

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

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

   641 

   642     // save the changes done above

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

   644 

   645     // save the message     

   646     clientMtm->SaveMessageL();

   647     	

   648 	// final fine tuning

   649     messageEntry.SetAttachment(EFalse);

   650     messageEntry.iDate.HomeTime();

   651     messageEntry.SetVisible(ETrue);

   652     messageEntry.SetInPreparation(EFalse);

   653    

   654     if (parameters.iCreateAsUnread)

   655         {

   656         messageEntry.SetUnread(ETrue);

   657         messageEntry.SetNew(ETrue);

   658         }

   659     else

   660         {

   661         messageEntry.SetUnread(EFalse);

   662         messageEntry.SetNew(EFalse);

   663         }

   664     

   665     messageEntry.SetComplete(ETrue);

   666     messageEntry.iServiceId = defaultServiceId;

   667     messageEntry.iRelatedId = 0;

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

   669 

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

   671     // only entries created with Creator

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

   673     

   674     CleanupStack::PopAndDestroy(2); //registry, clientMtm

   675         

   676     return err;

   677 

   678     }

   679 

   680 //----------------------------------------------------------------------------

   681 

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

   683     {

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

   685 

   686     TInt err = KErrNone;

   687 

   688         

   689     // init    

   690     if( iSession == 0 )

   691         {

   692         iSession = CMsvSession::OpenSyncL(*this);

   693         }

   694     

   695     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*iSession);

   696     CleanupStack::PushL(registry);

   697 

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

   699     CMmsClientMtm* clientMtm = NULL;

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

   701     if (err || !clientMtm)

   702         {

   703         CAknErrorNote* note = new(ELeave) CAknErrorNote;

   704         note->ExecuteLD(_L("MMS: Message type module not found"));

   705         CleanupStack::PopAndDestroy(2);

   706         User::Leave(KErrNotFound);

   707         }  

   708     CleanupStack::PushL(clientMtm);   

   709 

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

   711     CMsvEntry* msvEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

   712     CleanupStack::PushL(msvEntry);

   713   

   714     // get default service

   715     TMsvId defaultServiceId = 0;

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

   717     if (err)

   718         {

   719         CAknErrorNote* note = new(ELeave) CAknErrorNote;

   720         note->ExecuteLD(_L("MMS: Define MMS settings first"));

   721         CleanupStack::PopAndDestroy(4);

   722         User::Leave(KErrNotFound);

   723         } 

   724     

   725     // set folder type

   726     switch (parameters.iFolderType)

   727         {

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

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

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

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

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

   733         }

   734         

   735     // mtm takes ownership of entry context	

   736     CleanupStack::Pop(msvEntry);

   737     clientMtm->SetCurrentEntryL(msvEntry);    

   738     

   739     // create a new message

   740     clientMtm->CreateMessageL(defaultServiceId);

   741 

   742     // set subject

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

   744             

   745     // set some mms defaults

   746     clientMtm->SetMessageClass(EMmsClassPersonal);

   747     clientMtm->SetExpiryInterval(86400);

   748     clientMtm->SetDeliveryTimeInterval(3600);

   749     clientMtm->SetMessagePriority(EMmsPriorityLow);

   750     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   751     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   752     clientMtm->SetReadReply(EMmsReadReplyYes);        

   753     

   754     // set the sender / addressee field

   755     if (parameters.iFolderType == EInbox)

   756         {        

   757         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   758         }

   759     

   760     // Add all recipients to clientMtm

   761     AddRecipientsL( *clientMtm, parameters, EFalse );  

   762         

   763     // get an access to the message store

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

   765     CleanupStack::PushL(store);                  

   766    

   767 

   768     // set body as an attachment

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

   770     CleanupStack::PushL(mimeHeaders);

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

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

   773     mimeHeaders->SetMimeCharset( KMmsUtf8 );

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

   775     

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

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

   778     CleanupStack::PushL(attachmentInfo);

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

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

   781     mimeHeaders->StoreL( *attachmentInfo );

   782     

   783     RFile textFile;

   784 

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

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

   787     CleanupStack::Pop(); // waiter

   788     CleanupStack::Pop(); // attachmentInfo

   789     CleanupStack::PushL(waiter);

   790     waiter->StartAndWait();

   791     CleanupStack::PopAndDestroy(waiter);        

   792    

   793     HBufC8* tempBuf = HBufC8::NewLC( parameters.iMessageBodyText->Des().Length() );

   794     tempBuf->Des().Copy( parameters.iMessageBodyText->Des() );

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

   796     textFile.Close();

   797     CleanupStack::PopAndDestroy(); //tempBuf

   798     

   799     CleanupStack::PopAndDestroy(); //mimeHeaders

   800 

   801     

   802     // get the entry of the message

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

   804     

   805     // set the details field

   806     if (parameters.iFolderType == EInbox)

   807         {

   808         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

   809         }

   810     else

   811         {

   812         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

   813         }    

   814 

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

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

   817 

   818     // save the changes done above

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

   820     

   821 

   822       // save the attachments

   823     HandleAttachementsL(parameters, store, err );

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

   825 //        {

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

   827 //

   828 //        TParse parser;

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

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

   831 //

   832 //        // get the mime type

   833 //        RApaLsSession ls;

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

   835 //        CleanupClosePushL<RApaLsSession>(ls);

   836 //        TUid appUid;

   837 //        TDataType dataType;

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

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

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

   841 //        

   842 //        // attachment settings

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

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

   845 //        attachmentInfo->SetAttachmentNameL( shortFileName );        

   846 //        attachmentInfo->SetMimeTypeL( mimeType );        

   847 //

   848 //        // save

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

   850 //        

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

   852 //        if (err == KErrNone)

   853 //            waiter->StartAndWait();

   854 //        else

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

   856 //

   857 //        CleanupStack::PopAndDestroy(waiter);  

   858 //        }

   859 

   860     // save the changes made to the message store

   861     store->CommitL();

   862     CleanupStack::PopAndDestroy(store);   

   863            

   864     

   865     // save the message      

   866     clientMtm->SaveMessageL();

   867     	

   868 	// final fine tuning

   869 	messageEntry.SetAttachment(ETrue);

   870     messageEntry.iDate.HomeTime();

   871     messageEntry.SetVisible(ETrue);

   872     messageEntry.SetInPreparation(EFalse);

   873     if (parameters.iCreateAsUnread)

   874         {

   875         messageEntry.SetUnread(ETrue);

   876         messageEntry.SetNew(ETrue);

   877         }

   878     else

   879         {

   880         messageEntry.SetUnread(EFalse);

   881         messageEntry.SetNew(EFalse);

   882         }

   883     messageEntry.SetComplete(ETrue);

   884     messageEntry.iServiceId = defaultServiceId;

   885     messageEntry.iRelatedId = 0;

   886     

   887     if (parameters.iFolderType == EDrafts) 

   888         messageEntry.SetReadOnly(EFalse);

   889     else

   890         messageEntry.SetReadOnly(ETrue);

   891 

   892 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

   893 	

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

   895     

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

   897     // only entries created with Creator

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

   899     

   900     CleanupStack::PopAndDestroy(2); // registry, clientMtm        

   901         

   902 

   903     return err;

   904     }

   905 

   906 //----------------------------------------------------------------------------

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

   908     {

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

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

   911       {

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

   913       HandleAttachementL(store, err, sourceFileName );

   914 

   915       }    

   916   //Adding attachmentpaths

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

   918       {

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

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

   921       HandleAttachementL(store, err, sourceFileName );

   922       }

   923     }

   924 //----------------------------------------------------------------------------

   925 

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

   927     {

   928     TParse parser;

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

   930     TFileName shortFileName = parser.NameAndExt();

   931 

   932     // get the mime type

   933     RApaLsSession ls;

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

   935     CleanupClosePushL<RApaLsSession>(ls);

   936     TUid appUid;

   937     TDataType dataType;

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

   939     CleanupStack::PopAndDestroy(); //ls

   940     TPtrC8 mimeType = dataType.Des8();

   941     

   942     // attachment settings

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

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

   945     CleanupStack::PushL(attachmentInfo);

   946     attachmentInfo->SetAttachmentNameL( shortFileName );        

   947     attachmentInfo->SetMimeTypeL( mimeType );

   948     

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

   950         {

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

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

   953         CleanupStack::PushL(mimeHeaders);

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

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

   956         mimeHeaders->SetMimeCharset( KMmsUtf8 );

   957         mimeHeaders->StoreL( *attachmentInfo );

   958         CleanupStack::PopAndDestroy( mimeHeaders );

   959         }

   960 

   961     // save

   962     

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

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

   965     if (err == KErrNone)

   966     	{

   967         waiter->StartAndWait();

   968         CleanupStack::PopAndDestroy(waiter);

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

   970     	}

   971     else

   972     	{

   973     	CleanupStack::PopAndDestroy(waiter);

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

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

   976     	}

   977     }

   978       //----------------------------------------------------------------------------

   979 

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

   981     {

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

   983 

   984     TInt err = KErrNone;

   985 

   986         

   987     // init    

   988     if( iSession == 0 )

   989         {

   990         iSession = CMsvSession::OpenSyncL(*this);

   991         }

   992 

   993     CClientMtmRegistry* registry = CClientMtmRegistry::NewL(*iSession);

   994     CleanupStack::PushL(registry);

   995 

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

   997     CMmsClientMtm* clientMtm = NULL;

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

   999     if (err || !clientMtm)

  1000         {

  1001         CAknErrorNote* note = new(ELeave) CAknErrorNote;

  1002         note->ExecuteLD(_L("MMS: Message type module not found"));

  1003         CleanupStack::PopAndDestroy(2);

  1004         User::Leave(KErrNotFound);

  1005         }  

  1006     CleanupStack::PushL(clientMtm);   

  1007 

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

  1009     CMsvEntry* msvEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

  1010     CleanupStack::PushL(msvEntry);

  1011   

  1012     // get default service

  1013     TMsvId defaultServiceId = 0;

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

  1015     if (err)

  1016         {

  1017         CAknErrorNote* note = new(ELeave) CAknErrorNote;

  1018         note->ExecuteLD(_L("MMS: Define MMS settings first"));

  1019         CleanupStack::PopAndDestroy(2);

  1020         User::Leave(KErrNotFound);

  1021         } 

  1022     

  1023     // set folder type

  1024     switch (parameters.iFolderType)

  1025         {

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

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

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

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

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

  1031         }

  1032         

  1033     // mtm takes ownership of entry context	

  1034     CleanupStack::Pop(msvEntry);

  1035     clientMtm->SetCurrentEntryL(msvEntry);    

  1036     

  1037     // create a new message

  1038     clientMtm->CreateMessageL(defaultServiceId);

  1039 

  1040     // set subject

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

  1042             

  1043     // set some mms defaults

  1044     clientMtm->SetMessageClass(EMmsClassPersonal);

  1045     clientMtm->SetExpiryInterval(86400);

  1046     clientMtm->SetDeliveryTimeInterval(3600);

  1047     clientMtm->SetMessagePriority(EMmsPriorityLow);

  1048     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

  1049     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

  1050     clientMtm->SetReadReply(EMmsReadReplyYes);        

  1051     

  1052     // set the sender / addressee field

  1053     if (parameters.iFolderType == EInbox)

  1054         {

  1055         AddMtmSenderL(*clientMtm, parameters, EFalse);                

  1056         }

  1057 

  1058     // Add all recipients to clientMtm

  1059     AddRecipientsL( *clientMtm, parameters, EFalse );

  1060     

  1061         

  1062     // get an access to the message store

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

  1064     CleanupStack::PushL(store);                  

  1065    

  1066     // get the entry of the message

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

  1068     

  1069     // set the details field

  1070     if (parameters.iFolderType == EInbox)

  1071         {

  1072         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

  1073         }  

  1074     else

  1075         {

  1076         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

  1077         }

  1078 

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

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

  1081     messageEntry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;

  1082     

  1083     // save the changes done above

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

  1085     

  1086 

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

  1088     TParse parser;

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

  1090     TFileName shortFileName = parser.NameAndExt();

  1091 

  1092     // get the mime type

  1093     RApaLsSession ls;

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

  1095     CleanupClosePushL<RApaLsSession>(ls);

  1096     TUid appUid;

  1097     TDataType dataType;

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

  1099     CleanupStack::PopAndDestroy(); //ls

  1100     TPtrC8 mimeType = dataType.Des8();

  1101         

  1102     // attachment settings

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

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

  1105     attachmentInfo->SetAttachmentNameL( shortFileName );        

  1106     attachmentInfo->SetMimeTypeL( mimeType );        

  1107 

  1108     // save

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

  1110       

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

  1112     if (err == KErrNone)

  1113         waiter->StartAndWait();

  1114     else

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

  1116 

  1117     CleanupStack::PopAndDestroy(waiter);  

  1118 

  1119     // save the changes made to the message store

  1120     store->CommitL();

  1121     CleanupStack::PopAndDestroy(store);   

  1122            

  1123     

  1124     // save the message      

  1125     clientMtm->SaveMessageL();

  1126     	

  1127 	// final fine tuning

  1128 	messageEntry.SetAttachment(ETrue);

  1129     messageEntry.iDate.HomeTime();

  1130     messageEntry.SetVisible(ETrue);

  1131     messageEntry.SetInPreparation(EFalse);

  1132     if (parameters.iCreateAsUnread)

  1133         {

  1134         messageEntry.SetUnread(ETrue);