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 

    25 //#include <MuiuServiceUtilities.h>

    26 

    27 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__ && SYMBIAN_VERSION_SUPPORT < SYMBIAN_4)

    28 #include <MVPbkFieldType.h>

    29 #include <MVPbkContactOperationBase.h>

    30 #include <MVPbkStoreContactFieldCollection.h>

    31 #include <MVPbkContactFieldTextData.h>

    32 #include <CVPbkContactManager.h>

    33 #include <MVPbkStoreContact.h>

    34 

    35 #include <CVPbkContactStoreUriArray.h>

    36 #include <TVPbkContactStoreUriPtr.h>

    37 #include <VPbkContactStoreUris.h>

    38 #include <MVPbkContactStoreList.h>

    39 #include <MVPbkContactStore.h>

    40 #include <MVPbkContactStoreProperties.h>

    41 #include <VPbkEng.rsg>

    42 #include <cmsvrecipientlist.h>

    43 #endif

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

    45 

    46 

    47 //static const TInt KMessagesFieldLength = 1024;

    48 

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

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

    51 

    52 

    53 const TUid KUidBIOBusinessCardMsg =  {0x10005531}; 

    54 _LIT(KEmpty, "");

    55 

    56 //----------------------------------------------------------------------------

    57 

    58 CMessagesParameters::CMessagesParameters()

    59     {

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

    61 

    62     iSenderAddress = HBufC::New(128);

    63     iRecipientAddress = HBufC::New(128);

    64     iMessageSubject = HBufC::New(128);

    65     iMessageBodyText = HBufC::New(10240);

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

    67     iCreateAsUnread = ETrue;

    68     }

    69 

    70 CMessagesParameters::~CMessagesParameters()

    71     {

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

    73 

    74 

    75     delete iMessageBodyText;

    76     delete iMessageSubject;

    77     delete iRecipientAddress;

    78     delete iSenderAddress;

    79     delete iAttachments;

    80     iAttachmentPaths.ResetAndDestroy();

    81     iAttachmentPaths.Close(); 

    82     iRecipientAddressArray.ResetAndDestroy();

    83     iRecipientAddressArray.Close();

    84     iRecipientLinkIds.Close();

    85     iSenderLinkIds.Close();

    86     }

    87 

    88 //----------------------------------------------------------------------------

    89 

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

    91     {

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

    93     CleanupStack::Pop(self);

    94     return self;

    95     }

    96 

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

    98     {

    99     CCreatorMessages* self = new (ELeave) CCreatorMessages;

   100     CleanupStack::PushL(self);

   101     self->ConstructL(aEngine);

   102     return self;

   103     }

   104 

   105 CCreatorMessages::CCreatorMessages()

   106 :

   107 iSession(0)

   108     {

   109     }

   110 

   111 void CCreatorMessages::ConstructL(CCreatorEngine* aEngine)

   112     {

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

   114     iEngine = aEngine;

   115     

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

   117     iWaiter = CAsyncWaiter::NewL();

   118     }

   119 

   120 CCreatorMessages::~CCreatorMessages()

   121     {

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

   123 

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

   125         {

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

   127         }

   128     iEntryIds.Reset();

   129     iEntryIds.Close();

   130     

   131     delete iParameters;

   132     delete iWaiter;

   133     delete iTmpPhoneNumber;

   134     delete iTmpEmail;

   135     delete iAttachments;

   136 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__ && SYMBIAN_VERSION_SUPPORT < SYMBIAN_4)

   137     delete iExistingContacts;

   138     if( iContactManager )

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

   140     delete iContactManager;

   141     delete iTempContact;

   142 #endif

   143     iRecipientArray.ResetAndDestroy();

   144     iRecipientArray.Close();

   145     iSenderArray.ResetAndDestroy();

   146     iSenderArray.Close();

   147     delete iSession;

   148     }

   149 

   150 //----------------------------------------------------------------------------

   151 

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

   153     {

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

   155 

   156     if ( aCommand == ECmdDeleteMessages )

   157         {

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

   159         }

   160     else if ( aCommand ==  ECmdDeleteCreatorMessages )

   161         {

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

   163         }

   164 

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

   166         {

   167         

   168         // message type query

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

   170         if (dlg1->ExecuteLD(R_MESSAGE_TYPE_QUERY))

   171             {

   172             TInt folderTypeQueryResource(R_FOLDER_TYPE_QUERY);

   173             

   174             /*

   175             if (iMessageType == EEmail)

   176                 folderTypeQueryResource = R_FOLDER_TYPE_WITH_MAILBOX_QUERY;

   177             */

   178 

   179             // folder query

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

   181             if (dlg2->ExecuteLD(folderTypeQueryResource))

   182                 {

   183                 /*

   184                 if (iFolderType == EMailbox)

   185                     {

   186                     // array to hold mailbox names

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

   188                     CleanupStack::PushL(names);                    

   189                     

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

   191                     CleanupStack::PushL(session);

   192     

   193                     // generate list of mailboxes

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

   195                     CleanupStack::PushL(entrySelection);

   196 

   197                     TBool doReturn(EFalse);

   198                     

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

   200                         {

   201                         CAknInformationNote* note = new(ELeave) CAknInformationNote;

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

   203 

   204                         doReturn = ETrue;

   205                         }

   206                     else

   207                         {

   208                         // get mailbox names

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

   210                             {

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

   212                             CleanupStack::PushL(centry);

   213 

   214                             TMsvEntry tentry = centry->Entry();

   215                             names->AppendL(tentry.iDetails);

   216                             CleanupStack::PopAndDestroy(); //centry

   217                             }

   218                         

   219                         // show query

   220                         TInt index(0);

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

   222                         dlg->PrepareLC(R_MAILBOX_SELECTION_QUERY);

   223                         dlg->SetItemTextArray(names);

   224                         dlg->SetOwnershipType(ELbmDoesNotOwnItemArray);

   225 

   226                         if(dlg->RunLD())

   227                             {

   228                             iUserSelectedMailbox = entrySelection->At(index);

   229 

   230                             doReturn = EFalse;

   231                             }

   232                         else

   233                             {

   234                             doReturn = ETrue;

   235                             }    

   236                         

   237                         }

   238                     

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

   240                     

   241                     if (doReturn)

   242                         return EFalse;                    

   243                     }

   244                 */

   245                 

   246                 // query create as unread

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

   248                 if (dlg3->ExecuteLD(R_UNREAD_QUERY))

   249                     {                

   250 

   251                     // query number of characters in msg body

   252                     switch (iMessageType)

   253                         {

   254                         case ESMS:

   255                         case EMMS:

   256                         case EEmail:

   257                             {

   258                             iDefinedMessageLength = 100;

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

   260                                 {

   261                                 ;

   262                                 }

   263                             else

   264                                 return EFalse;

   265 

   266                             break;

   267                             }

   268                         case EAMS:

   269                         	{

   270                         	iDefinedMessageLength = 0;

   271                         	break;

   272                         	}

   273                         default: break;

   274                         }

   275 

   276                     // query attachments

   277                     iAttachments->Reset();

   278               

   279                     switch (iMessageType)

   280                         {

   281                         case EMMS:

   282                         case EEmail:

   283                             {

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

   285                             if (dlg4->ExecuteLD(R_ATTACHMENT_MULTI_SELECTION_QUERY))

   286                                 {

   287                                 // "none" is selected

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

   289                                     iAttachments->Reset();

   290                                 else  // otherwise fix indexes

   291                                     {

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

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

   294 

   295                                     }

   296                                 }

   297                             else

   298                                 return EFalse;

   299                             

   300                             break;

   301                             }

   302                         case EAMS:

   303                         	{

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

   305 

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

   307                             if (dlg5->ExecuteLD(R_AMS_ATTACHMENT_SINGLE_SELECTION_QUERY))

   308                                 {

   309                                 ;

   310                                 }

   311                             else

   312                                 return EFalse;                        

   313 

   314                             break;

   315                         	}

   316                             

   317                         case EIrMessage:

   318                         case EBTMessage:

   319                             {

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

   321 

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

   323                             if (dlg5->ExecuteLD(R_ATTACHMENT_SINGLE_SELECTION_QUERY))

   324                                 {

   325                                 ;

   326                                 }

   327                             else

   328                                 return EFalse;                        

   329 

   330                             break;

   331                             }

   332                         default: break;

   333                         }

   334                     

   335                     return ETrue;  // all queries accepted

   336 

   337                     }

   338                 else

   339                     return EFalse;

   340                 }

   341             else

   342                 return EFalse;

   343             }

   344         else

   345             return EFalse;

   346         }

   347     else

   348         return EFalse;

   349     }

   350 

   351 //----------------------------------------------------------------------------

   352 

   353 TInt CCreatorMessages::CreateRandomMessageEntryL(TInt aCommand)

   354     {

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

   356 

   357     TInt err = KErrNone;

   358     

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

   360 

   361 

   362     switch (aCommand)

   363         {

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

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

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

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

   368 	    

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

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

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

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

   373 	    

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

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

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

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

   378 	    

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

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

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

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

   383 	    

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

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

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

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

   388 	    

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

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

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

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

   393         

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

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

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

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

   398 

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

   400         }

   401 

   402     return err;

   403     }

   404 

   405 //----------------------------------------------------------------------------

   406 

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

   408     {

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

   410     

   411     delete iParameters;

   412     iParameters = 0;   

   413     

   414     CMessagesParameters* parameters = aParameters;

   415            

   416     // random data needed if no predefined data available

   417     if (!parameters)

   418         {

   419         iParameters = new(ELeave) CMessagesParameters;

   420         parameters = iParameters;

   421         // check if values from ui needed

   422         //if (aTakeUserGivenParameters)

   423         //    {            

   424             parameters->iMessageType = iMessageType;

   425             parameters->iFolderType = iFolderType;

   426             parameters->iDefinedMessageLength = iDefinedMessageLength;

   427             parameters->iCreateAsUnread = iCreateAsUnread;

   428 

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

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

   431         //    }

   432         //else

   433         //    {

   434             // message length

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

   436         //    }    

   437 

   438         if (parameters->iMessageType == EEmail)

   439             {

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

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

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

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

   444 

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

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

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

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

   449             }

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

   451             {

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

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

   454             }

   455         else

   456             {

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

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

   459             }

   460 

   461         // subject

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

   463 

   464         // message body

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

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

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

   468             {

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

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

   471             }

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

   473 

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

   475         parameters->iBIOMessageType = KUidBIOBusinessCardMsg;

   476         }

   477     

   478     

   479 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__ && SYMBIAN_VERSION_SUPPORT < SYMBIAN_4)

   480     

   481     // Get number of existing senders and recipients:

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

   483         {       

   484         

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

   486         // Is maximum number limited:

   487         if(recipientId.iLinkAmount == KUndef || 

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

   489             {

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

   491             }

   492         else

   493             {

   494             parameters->iNumberOfExistingRecipients += recipientId.iLinkAmount;

   495             }

   496         }

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

   498         {

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

   500         // Is maximum number limited:

   501         if( senderId.iLinkAmount == KUndef ||

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

   503             {

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

   505             }

   506         else

   507             {

   508             parameters->iNumberOfExistingSenders += senderId.iLinkAmount;

   509             }            

   510         }

   511     

   512 #endif

   513 

   514     TInt err = KErrNone;

   515 

   516     switch (parameters->iMessageType)

   517         {

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

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

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

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

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

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

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

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

   526 

   527         }

   528 

   529     iSenderArray.ResetAndDestroy();

   530     iRecipientArray.ResetAndDestroy();

   531     return err;

   532     }

   533 

   534 //----------------------------------------------------------------------------

   535 

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

   537     {

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

   539 

   540     TInt err = KErrNone;

   541                

   542     // init    

   543     if( iSession == 0 )

   544         {

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

   546         }

   547 

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

   549     CleanupStack::PushL(registry);

   550 

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

   552     CSmsClientMtm* clientMtm = NULL;

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

   554     if (err || !clientMtm)

   555         {

   556         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

   558         CleanupStack::PopAndDestroy(2);

   559         User::Leave(KErrNotFound);

   560         }  

   561     CleanupStack::PushL(clientMtm);   

   562 

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

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

   565     CleanupStack::PushL(msvEntry);

   566   

   567     // get default service

   568     TMsvId defaultServiceId = 0;

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

   570     if (err)

   571         {

   572         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

   574         CleanupStack::PopAndDestroy(2);

   575         User::Leave(KErrNotFound);

   576         } 

   577     

   578     // set folder type

   579     switch (parameters.iFolderType)

   580         {

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

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

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

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

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

   586         }

   587         

   588     // mtm takes ownership of entry context	

   589     CleanupStack::Pop(msvEntry);

   590     clientMtm->SetCurrentEntryL(msvEntry);    

   591     

   592     // create a new message

   593     clientMtm->CreateMessageL(defaultServiceId);

   594 

   595     // set the from field to sms header

   596     if (parameters.iFolderType == EInbox)

   597         {

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

   599 

   600         if( parameters.iSenderAddress )

   601             {

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

   603             }

   604         else

   605             {

   606             smsHeader.SetFromAddressL(KEmpty);

   607             }

   608         }       

   609 

   610     // set body

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

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

   613 

   614     // get the entry of the message

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

   616 

   617     // set the details field

   618     if (parameters.iFolderType == EInbox)

   619         {

   620         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

   621         }

   622     else

   623         {

   624         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

   625         // Add all recipients to clientMtm

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

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

   628             {

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

   630             }

   631         }

   632 

   633     // set the sending state for outbox message

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

   635     if (parameters.iFolderType == EOutbox )

   636         {

   637         messageEntry.SetSendingState( KMsvSendStateWaiting );

   638         }

   639 

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

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

   642 

   643     // save the changes done above

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

   645 

   646     // save the message     

   647     clientMtm->SaveMessageL();

   648     	

   649 	// final fine tuning

   650     messageEntry.SetAttachment(EFalse);

   651     messageEntry.iDate.HomeTime();

   652     messageEntry.SetVisible(ETrue);

   653     messageEntry.SetInPreparation(EFalse);

   654    

   655     if (parameters.iCreateAsUnread)

   656         {

   657         messageEntry.SetUnread(ETrue);

   658         messageEntry.SetNew(ETrue);

   659         }

   660     else

   661         {

   662         messageEntry.SetUnread(EFalse);

   663         messageEntry.SetNew(EFalse);

   664         }

   665     

   666     messageEntry.SetComplete(ETrue);

   667     messageEntry.iServiceId = defaultServiceId;

   668     messageEntry.iRelatedId = 0;

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

   670 

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

   672     // only entries created with Creator

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

   674     

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

   676         

   677     return err;

   678 

   679     }

   680 

   681 //----------------------------------------------------------------------------

   682 

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

   684     {

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

   686 

   687     TInt err = KErrNone;

   688 

   689         

   690     // init    

   691     if( iSession == 0 )

   692         {

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

   694         }

   695     

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

   697     CleanupStack::PushL(registry);

   698 

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

   700     CMmsClientMtm* clientMtm = NULL;

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

   702     if (err || !clientMtm)

   703         {

   704         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

   706         CleanupStack::PopAndDestroy(2);

   707         User::Leave(KErrNotFound);

   708         }  

   709     CleanupStack::PushL(clientMtm);   

   710 

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

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

   713     CleanupStack::PushL(msvEntry);

   714   

   715     // get default service

   716     TMsvId defaultServiceId = 0;

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

   718     if (err)

   719         {

   720         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

   722         CleanupStack::PopAndDestroy(4);

   723         User::Leave(KErrNotFound);

   724         } 

   725     

   726     // set folder type

   727     switch (parameters.iFolderType)

   728         {

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

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

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

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

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

   734         }

   735         

   736     // mtm takes ownership of entry context	

   737     CleanupStack::Pop(msvEntry);

   738     clientMtm->SetCurrentEntryL(msvEntry);    

   739     

   740     // create a new message

   741     clientMtm->CreateMessageL(defaultServiceId);

   742 

   743     // set subject

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

   745             

   746     // set some mms defaults

   747     clientMtm->SetMessageClass(EMmsClassPersonal);

   748     clientMtm->SetExpiryInterval(86400);

   749     clientMtm->SetDeliveryTimeInterval(3600);

   750     clientMtm->SetMessagePriority(EMmsPriorityLow);

   751     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

   752     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

   753     clientMtm->SetReadReply(EMmsReadReplyYes);        

   754     

   755     // set the sender / addressee field

   756     if (parameters.iFolderType == EInbox)

   757         {        

   758         AddMtmSenderL(*clientMtm, parameters, EFalse);                

   759         }

   760     

   761     // Add all recipients to clientMtm

   762     AddRecipientsL( *clientMtm, parameters, EFalse );  

   763         

   764     // get an access to the message store

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

   766     CleanupStack::PushL(store);                  

   767    

   768 

   769     // set body as an attachment

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

   771     CleanupStack::PushL(mimeHeaders);

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

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

   774     mimeHeaders->SetMimeCharset( KMmsUtf8 );

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

   776     

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

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

   779     CleanupStack::PushL(attachmentInfo);

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

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

   782     mimeHeaders->StoreL( *attachmentInfo );

   783     

   784     RFile textFile;

   785 

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

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

   788     CleanupStack::Pop(); // waiter

   789     CleanupStack::Pop(); // attachmentInfo

   790     CleanupStack::PushL(waiter);

   791     waiter->StartAndWait();

   792     CleanupStack::PopAndDestroy(waiter);        

   793    

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

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

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

   797     textFile.Close();

   798     CleanupStack::PopAndDestroy(); //tempBuf

   799     

   800     CleanupStack::PopAndDestroy(); //mimeHeaders

   801 

   802     

   803     // get the entry of the message

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

   805     

   806     // set the details field

   807     if (parameters.iFolderType == EInbox)

   808         {

   809         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

   810         }

   811     else

   812         {

   813         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

   814         }    

   815 

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

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

   818 

   819     // save the changes done above

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

   821     

   822 

   823       // save the attachments

   824     HandleAttachementsL(parameters, store, err );

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

   826 //        {

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

   828 //

   829 //        TParse parser;

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

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

   832 //

   833 //        // get the mime type

   834 //        RApaLsSession ls;

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

   836 //        CleanupClosePushL<RApaLsSession>(ls);

   837 //        TUid appUid;

   838 //        TDataType dataType;

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

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

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

   842 //        

   843 //        // attachment settings

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

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

   846 //        attachmentInfo->SetAttachmentNameL( shortFileName );        

   847 //        attachmentInfo->SetMimeTypeL( mimeType );        

   848 //

   849 //        // save

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

   851 //        

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

   853 //        if (err == KErrNone)

   854 //            waiter->StartAndWait();

   855 //        else

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

   857 //

   858 //        CleanupStack::PopAndDestroy(waiter);  

   859 //        }

   860 

   861     // save the changes made to the message store

   862     store->CommitL();

   863     CleanupStack::PopAndDestroy(store);   

   864            

   865     

   866     // save the message      

   867     clientMtm->SaveMessageL();

   868     	

   869 	// final fine tuning

   870 	messageEntry.SetAttachment(ETrue);

   871     messageEntry.iDate.HomeTime();

   872     messageEntry.SetVisible(ETrue);

   873     messageEntry.SetInPreparation(EFalse);

   874     if (parameters.iCreateAsUnread)

   875         {

   876         messageEntry.SetUnread(ETrue);

   877         messageEntry.SetNew(ETrue);

   878         }

   879     else

   880         {

   881         messageEntry.SetUnread(EFalse);

   882         messageEntry.SetNew(EFalse);

   883         }

   884     messageEntry.SetComplete(ETrue);

   885     messageEntry.iServiceId = defaultServiceId;

   886     messageEntry.iRelatedId = 0;

   887     

   888     if (parameters.iFolderType == EDrafts) 

   889         messageEntry.SetReadOnly(EFalse);

   890     else

   891         messageEntry.SetReadOnly(ETrue);

   892 

   893 	messageEntry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

   894 	

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

   896     

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

   898     // only entries created with Creator

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

   900     

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

   902         

   903 

   904     return err;

   905     }

   906 

   907 //----------------------------------------------------------------------------

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

   909     {

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

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

   912       {

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

   914       HandleAttachementL(store, err, sourceFileName );

   915 

   916       }    

   917   //Adding attachmentpaths

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

   919       {

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

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

   922       HandleAttachementL(store, err, sourceFileName );

   923       }

   924     }

   925 //----------------------------------------------------------------------------

   926 

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

   928     {

   929     TParse parser;

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

   931     TFileName shortFileName = parser.NameAndExt();

   932 

   933     // get the mime type

   934     RApaLsSession ls;

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

   936     CleanupClosePushL<RApaLsSession>(ls);

   937     TUid appUid;

   938     TDataType dataType;

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

   940     CleanupStack::PopAndDestroy(); //ls

   941     TPtrC8 mimeType = dataType.Des8();

   942     

   943     // attachment settings

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

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

   946     CleanupStack::PushL(attachmentInfo);

   947     attachmentInfo->SetAttachmentNameL( shortFileName );        

   948     attachmentInfo->SetMimeTypeL( mimeType );

   949     

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

   951         {

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

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

   954         CleanupStack::PushL(mimeHeaders);

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

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

   957         mimeHeaders->SetMimeCharset( KMmsUtf8 );

   958         mimeHeaders->StoreL( *attachmentInfo );

   959         CleanupStack::PopAndDestroy( mimeHeaders );

   960         }

   961 

   962     // save

   963     

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

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

   966     if (err == KErrNone)

   967     	{

   968         waiter->StartAndWait();

   969         CleanupStack::PopAndDestroy(waiter);

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

   971     	}

   972     else

   973     	{

   974     	CleanupStack::PopAndDestroy(waiter);

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

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

   977     	}

   978     }

   979       //----------------------------------------------------------------------------

   980 

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

   982     {

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

   984 

   985     TInt err = KErrNone;

   986 

   987         

   988     // init    

   989     if( iSession == 0 )

   990         {

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

   992         }

   993 

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

   995     CleanupStack::PushL(registry);

   996 

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

   998     CMmsClientMtm* clientMtm = NULL;

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

  1000     if (err || !clientMtm)

  1001         {

  1002         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

  1004         CleanupStack::PopAndDestroy(2);

  1005         User::Leave(KErrNotFound);

  1006         }  

  1007     CleanupStack::PushL(clientMtm);   

  1008 

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

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

  1011     CleanupStack::PushL(msvEntry);

  1012   

  1013     // get default service

  1014     TMsvId defaultServiceId = 0;

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

  1016     if (err)

  1017         {

  1018         CAknErrorNote* note = new(ELeave) CAknErrorNote;

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

  1020         CleanupStack::PopAndDestroy(2);

  1021         User::Leave(KErrNotFound);

  1022         } 

  1023     

  1024     // set folder type

  1025     switch (parameters.iFolderType)

  1026         {

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

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

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

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

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

  1032         }

  1033         

  1034     // mtm takes ownership of entry context	

  1035     CleanupStack::Pop(msvEntry);

  1036     clientMtm->SetCurrentEntryL(msvEntry);    

  1037     

  1038     // create a new message

  1039     clientMtm->CreateMessageL(defaultServiceId);

  1040 

  1041     // set subject

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

  1043             

  1044     // set some mms defaults

  1045     clientMtm->SetMessageClass(EMmsClassPersonal);

  1046     clientMtm->SetExpiryInterval(86400);

  1047     clientMtm->SetDeliveryTimeInterval(3600);

  1048     clientMtm->SetMessagePriority(EMmsPriorityLow);

  1049     clientMtm->SetSenderVisibility(EMmsMaximumSenderVisibility);

  1050     clientMtm->SetDeliveryReport(EMmsDeliveryReportYes);

  1051     clientMtm->SetReadReply(EMmsReadReplyYes);        

  1052     

  1053     // set the sender / addressee field

  1054     if (parameters.iFolderType == EInbox)

  1055         {

  1056         AddMtmSenderL(*clientMtm, parameters, EFalse);                

  1057         }

  1058 

  1059     // Add all recipients to clientMtm

  1060     AddRecipientsL( *clientMtm, parameters, EFalse );

  1061     

  1062         

  1063     // get an access to the message store

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

  1065     CleanupStack::PushL(store);                  

  1066    

  1067     // get the entry of the message

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

  1069     

  1070     // set the details field

  1071     if (parameters.iFolderType == EInbox)

  1072         {

  1073         SetSenderToEntryDetails(messageEntry, parameters, EFalse);        

  1074         }  

  1075     else

  1076         {

  1077         SetRecipientToEntryDetails(messageEntry, parameters, EFalse);

  1078         }

  1079 

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

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

  1082     messageEntry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;

  1083     

  1084     // save the changes done above

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

  1086     

  1087 

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

  1089     TParse parser;

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

  1091     TFileName shortFileName = parser.NameAndExt();

  1092 

  1093     // get the mime type

  1094     RApaLsSession ls;

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

  1096     CleanupClosePushL<RApaLsSession>(ls);

  1097     TUid appUid;

  1098     TDataType dataType;

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

  1100     CleanupStack::PopAndDestroy(); //ls

  1101     TPtrC8 mimeType = dataType.Des8();

  1102         

  1103     // attachment settings

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

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

  1106     attachmentInfo->SetAttachmentNameL( shortFileName );        

  1107     attachmentInfo->SetMimeTypeL( mimeType );        

  1108 

  1109     // save

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

  1111       

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

  1113     if (err == KErrNone)

  1114         waiter->StartAndWait();

  1115     else

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

  1117 

  1118     CleanupStack::PopAndDestroy(waiter);  

  1119 

  1120     // save the changes made to the message store

  1121     store->CommitL();

  1122     CleanupStack::PopAndDestroy(store);   

  1123            

  1124     

  1125     // save the message      

  1126     clientMtm->SaveMessageL();

  1127     	

  1128 	// final fine tuning

  1129 	messageEntry.SetAttachment(ETrue);

  1130     messageEntry.iDate.HomeTime();

  1131     messageEntry.SetVisible(ETrue);

  1132     messageEntry.SetInPreparation(EFalse);

  1133     if (parameters.iCreateAsUnread)