1 /*

     2 * Copyright (c) 2009 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:  Functional implementation of HtiMessagesServicePlugin service

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "HtiMessagesServicePlugin.h"

    21 #include "MessageMgmntHandler.h"

    22 

    23 #include <HtiDispatcherInterface.h>

    24 #include <HTILogging.h>

    25 #include <mtclreg.h>

    26 #include <smscmds.h>

    27 #include <smtcmtm.h>

    28 #include <smuthdr.h>

    29 #include <smsclnt.h>

    30 #include <utf.h>

    31 #include <mmsclient.h>

    32 #include <mmsconst.h>

    33 #include <miutset.h>

    34 #include <irmsgtypeuid.h>

    35 #include <btmsgtypeuid.h>

    36 #include <biouids.h>

    37 #include <apgcli.h>

    38 #include <apmstd.h>

    39 #include <bautils.h>

    40 #include <obexclientmtm.h>

    41 #include <cmsvmimeheaders.h>

    42 #include <mmsvattachmentmanager.h>

    43 

    44 // CONSTANTS

    45 _LIT8( KErrorMissingCommand,        "Command was not given - message was empty" );

    46 _LIT8( KErrorUnrecognizedCommand,   "Unrecognized command" );

    47 _LIT8( KErrorInvalidParameters,     "Invalid command parameters");

    48 _LIT8( KErrorTooLongSmsBody,        "Too long SMS body" );

    49 _LIT8( KErrorInvalidId,             "Invalid SMS id parameter" );

    50 _LIT8( KErrorInvalidFolder,         "Invalid folder parameter" );

    51 _LIT8( KErrorItemNotFound,          "Item not found" );

    52 _LIT8( KErrorFailedDelete,          "Failed to delete item" );

    53 _LIT8( KErrorNotSupported,          "Not supported" );

    54 _LIT8( KErrorSmsSettingNotDefined,  "SMS settings not defined" );

    55 _LIT8( KErrorMmsSettingNotDefined,  "MMS settings not defined" );

    56 _LIT8( KErrorMailboxNotDefined,     "Mailbox not defined" );

    57 _LIT8( KErrorMsgTypeNotFound,       "Message type module not found" );

    58 _LIT8( KErrorMsgStoreOpenFailed,    "Could not open message store" );

    59 _LIT8( KErrorRfsConnectFailed,      "Could not connect to file server session" );

    60 _LIT8( KErrorAttachmentNotFound,    "Attachment not found" );

    61 _LIT8( KErrorInvalidFolderForSmartMsg, "Only inbox allowed for smart messages" );

    62 

    63 const static TInt KAddSmsCmdMinLength        = 7;

    64 const static TInt KAddMmsOrEmailCmdMinLength = 8;

    65 const static TInt KAddObexMsgCmdMinLength    = 6;

    66 const static TInt KAddSmartMsgCmdMinLength   = 11;

    67 const static TInt KAddAudioCmdMinLength      = 10;

    68 

    69 // ----------------------------------------------------------------------------

    70 CMessageMgmntHandler* CMessageMgmntHandler::NewL()

    71     {

    72     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::NewL" );

    73     CMessageMgmntHandler* self = new (ELeave) CMessageMgmntHandler();

    74     CleanupStack::PushL ( self );

    75     self->ConstructL();

    76     CleanupStack::Pop();

    77     HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::NewL: Done" );

    78     return self;

    79     }

    80 

    81 // ----------------------------------------------------------------------------

    82 CMessageMgmntHandler::CMessageMgmntHandler()

    83     {

    84     }

    85 

    86 // ----------------------------------------------------------------------------

    87 CMessageMgmntHandler::~CMessageMgmntHandler()

    88     {

    89     delete iMtmReg;

    90     delete iSession;

    91     }

    92 

    93 // ----------------------------------------------------------------------------

    94 void CMessageMgmntHandler::ConstructL()

    95     {

    96     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::ConstructL" );

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

    98     iMtmReg = CClientMtmRegistry::NewL( *iSession );

    99     HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::ConstructL: Done" );

   100     }

   101 

   102 // ----------------------------------------------------------------------------

   103 void CMessageMgmntHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

   104     {

   105     iDispatcher = aDispatcher;

   106     }

   107 

   108 // ----------------------------------------------------------------------------

   109 void CMessageMgmntHandler::ProcessMessageL( const TDesC8& aMessage,

   110                                             THtiMessagePriority /*aPriority*/ )

   111     {

   112     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::ProcessMessageL" );

   113     HTI_LOG_FORMAT( "Msg length: %d", aMessage.Length() );

   114 

   115     if ( aMessage.Length() == 0 )

   116         {

   117         SendErrorMessageL( KErrArgument, KErrorMissingCommand );

   118         return;

   119         }

   120 

   121     switch ( aMessage[0] )

   122         {

   123         case CHtiMessagesServicePlugin::EAddSms:

   124             HTI_LOG_TEXT( "Add SMS" );

   125             HandleCreateSmsL( aMessage.Right( aMessage.Length() - 1 ) );

   126             break;

   127 

   128         case CHtiMessagesServicePlugin::EAddMms:

   129         case CHtiMessagesServicePlugin::EAddAudioMsg: // special MMS sub type

   130             HTI_LOG_TEXT( "Add MMS" );

   131             HandleCreateMmsL( aMessage );

   132             break;

   133 

   134         case CHtiMessagesServicePlugin::EAddEmail:

   135             HTI_LOG_TEXT( "Add Email" );

   136             HandleCreateEmailL( aMessage );

   137             break;

   138 

   139         case CHtiMessagesServicePlugin::EAddIrMsg:

   140             HTI_LOG_TEXT( "Add IR msg" );

   141             HandleCreateObexMsgL( aMessage.Right( aMessage.Length() - 1 ),

   142                                   TUid::Uid( KUidMsgTypeIrTInt32 ),

   143                                   KUidMsgTypeIrUID );

   144             break;

   145 

   146         case CHtiMessagesServicePlugin::EAddBtMsg:

   147             HTI_LOG_TEXT( "Add BT msg" );

   148             HandleCreateObexMsgL( aMessage.Right( aMessage.Length() - 1 ),

   149                                   TUid::Uid( KUidMsgTypeBtTInt32 ),

   150                                   KUidMsgTypeBt );

   151             break;

   152 

   153         case CHtiMessagesServicePlugin::EAddSmartMsg:

   154             HTI_LOG_TEXT( "Add smart msg" );

   155             HandleCreateSmartMsgL( aMessage.Right( aMessage.Length() - 1 ) );

   156             break;

   157 

   158         case CHtiMessagesServicePlugin::EDeleteMessage:

   159             HTI_LOG_TEXT( "Delete message" );

   160             HandleDeleteMessageL( aMessage.Right( aMessage.Length() - 1 ) );

   161             break;

   162 

   163         case CHtiMessagesServicePlugin::EDeleteFolderContent:

   164             HTI_LOG_TEXT( "Delete messages" );

   165             HandleDeleteMessagesL( aMessage.Right( aMessage.Length() - 1 ) );

   166             break;

   167 

   168         default:

   169             HTI_LOG_TEXT( "Unknown command" );

   170             SendErrorMessageL( KErrUnknown, KErrorUnrecognizedCommand );

   171             break;

   172         }

   173 

   174     HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::ProcessMessageL: Done" );

   175     }

   176 

   177 // ----------------------------------------------------------------------------

   178 void CMessageMgmntHandler::HandleCreateSmsL( const TDesC8& aData )

   179     {

   180     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleSmsImportFuncL" );

   181 

   182     if ( ValidateAddSmsCommand( aData ) )

   183         {

   184         TInt position( 0 );

   185         HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

   186         HBufC16* description = ExtractDesLC( aData, position, 1 );

   187         HBufC16* body = ExtractDesLC( aData, position, 2 );

   188         TBool isNew = (TBool)aData[position];

   189         TBool isUnread = (TBool)aData[position+1];

   190         TFolder folder = (TFolder)aData[position+2];

   191 

   192         CSmsClientMtm* smsMtm = NULL;

   193         TRAPD( err, smsMtm = ( CSmsClientMtm* )iMtmReg->NewMtmL(

   194                 KUidMsgTypeSMS ) );

   195         if ( err || !smsMtm )

   196             {

   197             HTI_LOG_TEXT( "SMS message type module not found" );

   198             SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

   199             CleanupStack::PopAndDestroy( body );

   200             CleanupStack::PopAndDestroy( description );

   201             CleanupStack::PopAndDestroy( fromTo );

   202             return;

   203             }

   204         CleanupStack::PushL( smsMtm );

   205 

   206         CMsvEntry* entry = CMsvEntry::NewL( *iSession,

   207                                             KMsvGlobalInBoxIndexEntryId,

   208                                             TMsvSelectionOrdering() );

   209         CleanupStack::PushL( entry );

   210 

   211         // get the default service

   212         TMsvId defaultServiceId = 0;

   213         TRAP( err, defaultServiceId = smsMtm->DefaultServiceL() );

   214         if ( err )

   215             {

   216             HTI_LOG_FORMAT( "Could not get default service, err: %d", err );

   217             SendErrorMessageL( err, KErrorSmsSettingNotDefined );

   218             CleanupStack::PopAndDestroy( entry );

   219             CleanupStack::PopAndDestroy( smsMtm );

   220             CleanupStack::PopAndDestroy( body );

   221             CleanupStack::PopAndDestroy( description );

   222             CleanupStack::PopAndDestroy( fromTo );

   223             return;

   224             }

   225 

   226         // map the folder parameter to folder id

   227         TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

   228         TRAP( err, folderId = MapFolderToIdL( folder ) );

   229         if ( err )

   230             {

   231             HTI_LOG_FORMAT( "Invalid folder: %d", folder );

   232             SendErrorMessageL( err, KErrorInvalidFolder );

   233             CleanupStack::PopAndDestroy( entry );

   234             CleanupStack::PopAndDestroy( smsMtm );

   235             CleanupStack::PopAndDestroy( body );

   236             CleanupStack::PopAndDestroy( description );

   237             CleanupStack::PopAndDestroy( fromTo );

   238             return;

   239             }

   240         entry->SetEntryL( folderId );

   241 

   242         // mtm takes ownership of entry context

   243         smsMtm->SetCurrentEntryL( entry );

   244         CleanupStack::Pop( entry );

   245 

   246         // create a new message

   247         smsMtm->CreateMessageL( defaultServiceId );

   248 

   249         if ( folder == EInbox )

   250             {

   251             CSmsHeader* smsHeader = &( smsMtm->SmsHeader() );

   252             delete smsHeader;

   253             smsHeader = NULL;

   254             smsHeader = CSmsHeader::NewL( CSmsPDU::ESmsDeliver, smsMtm->Body() );

   255             smsHeader->SetFromAddressL( fromTo->Des() );

   256             }

   257         else

   258             {

   259             smsMtm->AddAddresseeL( fromTo->Des() );

   260 

   261             // set delivery settings

   262             CSmsSettings* sendOptions = CSmsSettings::NewL();

   263             CleanupStack::PushL( sendOptions );

   264             sendOptions->CopyL( smsMtm->ServiceSettings() );

   265             sendOptions->SetDelivery( ESmsDeliveryImmediately );

   266 

   267             CSmsHeader* smsHeader = &( smsMtm->SmsHeader() );

   268             smsHeader->SetSmsSettingsL( *sendOptions );

   269             CleanupStack::PopAndDestroy( sendOptions );

   270             }

   271 

   272 

   273 

   274         // set body

   275         smsMtm->Body().Reset();

   276         smsMtm->Body().InsertL( 0, *body );

   277 

   278         // save the message

   279         smsMtm->SaveMessageL();

   280 

   281         // get the entry of the message

   282         TMsvEntry tentry = smsMtm->Entry().Entry();

   283 

   284         // set the details field

   285         tentry.iDetails.Set( fromTo->Des() );

   286 

   287         // set the description field if it is given.

   288         // (with no description the beginning of the message body

   289         //  is used as a description)

   290         if ( description->Length() > 0 )

   291             {

   292             tentry.iDescription.Set( description->Des() );

   293             }

   294 

   295         // final fine tuning

   296         tentry.SetAttachment( EFalse );

   297         tentry.iDate.UniversalTime();

   298         tentry.SetVisible( ETrue );

   299         tentry.SetInPreparation( EFalse );

   300         tentry.SetUnread( isUnread );

   301         tentry.SetNew( isNew );

   302         tentry.SetComplete( ETrue );

   303         tentry.SetSendingState( KMsvSendStateWaiting );

   304         tentry.iServiceId = defaultServiceId;

   305         tentry.iRelatedId = 0;

   306         if ( folder == EInbox )

   307             {

   308             tentry.SetReadOnly( ETrue );

   309             }

   310 

   311         smsMtm->Entry().ChangeL( tentry );

   312 

   313         // send the message, if it is in outbox

   314         if ( folder == EOutbox )

   315             {

   316             CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   317             CleanupStack::PushL( selection );

   318             selection->AppendL( tentry.Id() );

   319 

   320             TBuf8<1> dummyParameter;

   321             CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

   322             CMsvOperation* op = smsMtm->InvokeAsyncFunctionL(

   323                     ESmsMtmCommandScheduleCopy, *selection,

   324                     dummyParameter, waiter->iStatus );

   325             CleanupStack::PushL( op );

   326             waiter->Start();

   327             CActiveScheduler::Start();

   328             CleanupStack::PopAndDestroy( op );

   329             CleanupStack::PopAndDestroy( waiter );

   330             CleanupStack::PopAndDestroy( selection );

   331             }

   332 

   333         CleanupStack::PopAndDestroy( smsMtm );

   334         CleanupStack::PopAndDestroy( body );

   335         CleanupStack::PopAndDestroy( description );

   336         CleanupStack::PopAndDestroy( fromTo );

   337 

   338         TInt32 id = tentry.Id();

   339         TBuf8<8> idStr;

   340         idStr.Copy( ( TUint8* )( &id ), sizeof( id ) );

   341         SendOkMsgL( idStr );

   342         }

   343 

   344     HTI_LOG_FUNC_OUT("CMessageMgmntHandler::HandleSmsImportFuncL: Done");

   345     }

   346 

   347 // ----------------------------------------------------------------------------

   348 void CMessageMgmntHandler::HandleCreateMmsL( const TDesC8& aData )

   349     {

   350     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleCreateMmsL" );

   351 

   352     if ( !ValidateAddMmsOrAddEmailCommand( aData ) )

   353         {

   354         // Error message has been sent from validation method.

   355         return;

   356         }

   357 

   358     // parse the parameters

   359     TInt position( 0 );

   360     TInt cmdCode = aData[position];

   361     position++;

   362     HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

   363     HBufC16* description = ExtractDesLC( aData, position, 1 );

   364     HBufC8* body = NULL;

   365     if ( cmdCode == CHtiMessagesServicePlugin::EAddMms )

   366         {

   367         body = ExtractDes8LC( aData, position, 2 );

   368         }

   369     else // Audio msg does not have body text

   370         {

   371         body = HBufC8::NewLC( 0 );

   372         }

   373     HBufC16* attPath = ExtractDesLC( aData, position, 1 );

   374     TBool isNew = (TBool)aData[position];

   375     TBool isUnread = (TBool)aData[position+1];

   376     TFolder folder = (TFolder)aData[position+2];

   377 

   378     HTI_LOG_TEXT( "Creating MMS Client MTM" );

   379     CMmsClientMtm* mmsMtm = NULL;

   380     TRAPD( err , mmsMtm = ( CMmsClientMtm* )iMtmReg->NewMtmL(

   381             KUidMsgTypeMultimedia ) );

   382     if ( err || !mmsMtm )

   383         {

   384         HTI_LOG_TEXT( "MMS message type module not found" );

   385         SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

   386         CleanupStack::PopAndDestroy( attPath );

   387         CleanupStack::PopAndDestroy( body );

   388         CleanupStack::PopAndDestroy( description );

   389         CleanupStack::PopAndDestroy( fromTo );

   390         return;

   391         }

   392     CleanupStack::PushL( mmsMtm );

   393 

   394     HTI_LOG_TEXT( "Creating MMS Client MTM" );

   395     CMsvEntry* entry = CMsvEntry::NewL( *iSession,

   396                                         KMsvGlobalInBoxIndexEntryId,

   397                                         TMsvSelectionOrdering() );

   398     CleanupStack::PushL( entry );

   399 

   400     // get the default service

   401     TMsvId defaultServiceId = 0;

   402     TRAP( err, defaultServiceId = mmsMtm->DefaultServiceL() );

   403     if ( err )

   404         {

   405         HTI_LOG_FORMAT( "Could not get default service, err: %d", err );

   406         SendErrorMessageL( err, KErrorMmsSettingNotDefined );

   407         CleanupStack::PopAndDestroy( entry );

   408         CleanupStack::PopAndDestroy( mmsMtm );

   409         CleanupStack::PopAndDestroy( attPath );

   410         CleanupStack::PopAndDestroy( body );

   411         CleanupStack::PopAndDestroy( description );

   412         CleanupStack::PopAndDestroy( fromTo );

   413         return;

   414         }

   415 

   416     // map the folder parameter to folder id

   417     TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

   418     TRAP( err, folderId = MapFolderToIdL( folder ) );

   419     if ( err )

   420         {

   421         HTI_LOG_FORMAT( "Invalid folder: %d", folder );

   422         SendErrorMessageL( err, KErrorInvalidFolder );

   423         CleanupStack::PopAndDestroy( entry );

   424         CleanupStack::PopAndDestroy( mmsMtm );

   425         CleanupStack::PopAndDestroy( attPath );

   426         CleanupStack::PopAndDestroy( body );

   427         CleanupStack::PopAndDestroy( description );

   428         CleanupStack::PopAndDestroy( fromTo );

   429         return;

   430         }

   431     entry->SetEntryL( folderId );

   432 

   433     // mtm takes ownership of entry context

   434     mmsMtm->SetCurrentEntryL( entry );

   435     CleanupStack::Pop( entry );

   436 

   437     HTI_LOG_TEXT( "Creating MMS..." );

   438     mmsMtm->CreateMessageL( defaultServiceId );

   439     mmsMtm->SetMessageClass( EMmsClassPersonal );

   440     mmsMtm->SetExpiryInterval( 86400 );

   441     mmsMtm->SetDeliveryTimeInterval( 0 );

   442     mmsMtm->SetMessagePriority( EMmsPriorityNormal );

   443     mmsMtm->SetSenderVisibility( EMmsMaximumSenderVisibility );

   444     mmsMtm->SetDeliveryReport( EMmsDeliveryReportNo );

   445     mmsMtm->SetReadReply( EMmsReadReplyYes );

   446 

   447     if ( description->Length() > 0 )

   448         {

   449         mmsMtm->SetSubjectL( description->Des() );

   450         }

   451 

   452     if ( folder == EInbox )

   453         {

   454         mmsMtm->SetSenderL( fromTo->Des() );

   455         }

   456     else

   457         {

   458         mmsMtm->AddAddresseeL( fromTo->Des() );

   459         }

   460 

   461     // get an access to the message store

   462     HTI_LOG_TEXT( "Getting message store..." );

   463     CMsvStore* store = NULL;

   464     TRAP( err, store = entry->EditStoreL() );

   465     if ( err )

   466         {

   467         HTI_LOG_FORMAT( "Could not get access to message store, err: %d", err );

   468         SendErrorMessageL( err, KErrorMsgStoreOpenFailed );

   469         CleanupStack::PopAndDestroy( mmsMtm );

   470         CleanupStack::PopAndDestroy( attPath );

   471         CleanupStack::PopAndDestroy( body );

   472         CleanupStack::PopAndDestroy( description );

   473         CleanupStack::PopAndDestroy( fromTo );

   474         return;

   475         }

   476     CleanupStack::PushL( store );

   477 

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

   479     // set body attachment only for normal MMS - audio message doesn't have body

   480     if ( cmdCode == CHtiMessagesServicePlugin::EAddMms )

   481         {

   482         // Set the message body as attachment

   483         // Use UTF-8 as charset because MMS created with MMS editor seems to

   484         // save text attachments also as UTF-8.

   485         HTI_LOG_TEXT( "Setting body..." );

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

   487         CleanupStack::PushL( mimeHeaders );

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

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

   490         mimeHeaders->SetMimeCharset( KMmsUtf8 );

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

   492 

   493         // ownership of bodyAttachment will be transferred

   494         CMsvAttachment* bodyAttachment = CMsvAttachment::NewL(

   495                 CMsvAttachment::EMsvFile );

   496         CleanupStack::PushL( bodyAttachment );

   497         bodyAttachment->SetAttachmentNameL( _L( "body.txt" ) );

   498         bodyAttachment->SetMimeTypeL( _L8( "text/plain" ) );

   499         mimeHeaders->StoreL( *bodyAttachment );

   500 

   501         RFile textFile;

   502         CleanupClosePushL( textFile );

   503         CWaiter* waiter = CWaiter::NewLC();

   504         attachMan.CreateAttachmentL( _L( "body.txt" ), textFile,

   505                 bodyAttachment, waiter->iStatus );

   506         waiter->StartAndWait();

   507         CleanupStack::PopAndDestroy( waiter );

   508 

   509         // write the UTF-8 body data to attachment file

   510         textFile.Write( *body );

   511         CleanupStack::PopAndDestroy(); // textFile

   512         CleanupStack::Pop( bodyAttachment ); // ownership transfered

   513         CleanupStack::PopAndDestroy( mimeHeaders );

   514         }

   515 

   516     // get the entry of the message

   517     TMsvEntry tentry = mmsMtm->Entry().Entry();

   518 

   519     // set the details field

   520     tentry.iDetails.Set( *fromTo );

   521 

   522     // set the description field

   523     if ( description->Length() > 0 )

   524         {

   525         tentry.iDescription.Set( description->Left( KMmsMaxDescription ) );

   526         }

   527     else

   528         {

   529         TBuf<KMmsMaxDescription> descr;

   530         CnvUtfConverter::ConvertToUnicodeFromUtf8( descr, *body );

   531         tentry.iDescription.Set( descr );

   532         }

   533 

   534     // if this is audio message, set the bio type uid

   535     if ( cmdCode == CHtiMessagesServicePlugin::EAddAudioMsg )

   536         {

   537         tentry.iBioType = KUidMsgSubTypeMmsAudioMsg.iUid;

   538         }

   539 

   540     // handle attachment

   541     TBool attachmentsExist = EFalse;

   542     if ( attPath->Length() > 0 )

   543         {

   544         HTI_LOG_TEXT( "Handling attachment..." );

   545         // check that attachment exists

   546         RFs fsSession;

   547         if ( fsSession.Connect() != KErrNone )

   548             {

   549             HTI_LOG_FORMAT( "Error in connecting to file server session: %d", err );

   550             SendErrorMessageL( KErrCouldNotConnect, KErrorRfsConnectFailed );

   551             CleanupStack::PopAndDestroy( store );

   552             CleanupStack::PopAndDestroy( mmsMtm );

   553             CleanupStack::PopAndDestroy( attPath );

   554             CleanupStack::PopAndDestroy( body );

   555             CleanupStack::PopAndDestroy( description );

   556             CleanupStack::PopAndDestroy( fromTo );

   557             return;

   558             }

   559 

   560         TBool fileExists = BaflUtils::FileExists( fsSession, attPath->Des() );

   561         fsSession.Close();

   562         if ( !fileExists )

   563             {

   564             HTI_LOG_TEXT( "Attachment file not found" );

   565             SendErrorMessageL( KErrPathNotFound, KErrorAttachmentNotFound );

   566             store->RevertL();

   567             CleanupStack::PopAndDestroy( store );

   568             CleanupStack::PopAndDestroy( mmsMtm );

   569             CleanupStack::PopAndDestroy( attPath );

   570             CleanupStack::PopAndDestroy( body );

   571             CleanupStack::PopAndDestroy( description );

   572             CleanupStack::PopAndDestroy( fromTo );

   573             return;

   574             }

   575         else

   576             {

   577             // save the attachment

   578             TParse parser;

   579             parser.Set( *attPath, NULL, NULL);

   580             TFileName shortFileName = parser.NameAndExt();

   581 

   582             // get the mime type

   583             RApaLsSession ls;

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

   585             CleanupClosePushL( ls );

   586             TUid appUid;

   587             TDataType dataType;

   588             ls.AppForDocument( *attPath, appUid, dataType );

   589             CleanupStack::PopAndDestroy(); // ls

   590             TPtrC8 mimeType = dataType.Des8();

   591 

   592             // attachment settings

   593             // ownership of attachment will be transferred

   594             CMsvAttachment* attachment = CMsvAttachment::NewL(

   595                     CMsvAttachment::EMsvFile );

   596             attachment->SetAttachmentNameL( shortFileName );

   597             attachment->SetMimeTypeL( mimeType );

   598 

   599             // save

   600             CWaiter* waiter = CWaiter::NewLC();

   601             attachMan.AddAttachmentL( *attPath, attachment, waiter->iStatus );

   602             waiter->StartAndWait();

   603             CleanupStack::PopAndDestroy( waiter );

   604             attachmentsExist = ETrue;

   605             }

   606         }

   607 

   608     // save the changes made to the message store

   609     store->CommitL();

   610     CleanupStack::PopAndDestroy( store );

   611 

   612     // save the message

   613     mmsMtm->SaveMessageL();

   614 

   615     // final fine tuning

   616     tentry.SetAttachment( attachmentsExist );

   617     tentry.iDate.UniversalTime();

   618     tentry.SetVisible( ETrue );

   619     tentry.SetInPreparation( EFalse );

   620     if ( folder == EDrafts )

   621         {

   622         tentry.SetReadOnly( EFalse );

   623         }

   624     else

   625         {

   626         tentry.SetReadOnly( ETrue );

   627         }

   628     tentry.SetUnread( isUnread );

   629     tentry.SetNew( isNew );

   630     tentry.SetComplete( ETrue );

   631     tentry.SetSendingState( KMsvSendStateWaiting );

   632     tentry.iServiceId = defaultServiceId;

   633     tentry.iRelatedId = 0;

   634     tentry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;

   635 

   636     mmsMtm->Entry().ChangeL( tentry );

   637 

   638     HTI_LOG_TEXT( "MMS created and ready" );

   639 

   640     // send the message, if it is in outbox

   641     if ( folder == EOutbox )

   642         {

   643         HTI_LOG_TEXT( "MMS is in Outbox, sending it..." );

   644 

   645         CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   646         CleanupStack::PushL( selection );

   647         selection->AppendL( tentry.Id() );

   648 

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

   650         CMsvOperation* op = mmsMtm->SendL( *selection,

   651                                            waiter->iStatus,

   652                                            tentry.iDate );

   653         CleanupStack::PushL( op );

   654         waiter->Start();

   655         CActiveScheduler::Start();

   656         CleanupStack::PopAndDestroy( op );

   657         CleanupStack::PopAndDestroy( waiter );

   658         CleanupStack::PopAndDestroy( selection );

   659         }

   660 

   661     HTI_LOG_TEXT( "Cleaning up" );

   662     CleanupStack::PopAndDestroy( mmsMtm );

   663     CleanupStack::PopAndDestroy( attPath );

   664     CleanupStack::PopAndDestroy( body );

   665     CleanupStack::PopAndDestroy( description );

   666     CleanupStack::PopAndDestroy( fromTo );

   667 

   668     // send the message id back

   669     TInt32 id = tentry.Id();

   670     TBuf8<8> idStr;

   671     idStr.Copy( ( TUint8* )( &id ), sizeof( id ) );

   672     SendOkMsgL( idStr );

   673 

   674     HTI_LOG_FUNC_OUT("CMessageMgmntHandler::HandleCreateMmsL: Done");

   675     }

   676 

   677 

   678 // ----------------------------------------------------------------------------

   679 void CMessageMgmntHandler::HandleCreateEmailL( const TDesC8& aData )

   680     {

   681     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleCreateEmailL" );

   682 

   683     if ( ValidateAddMmsOrAddEmailCommand( aData ) )

   684         {

   685         // parse the parameters

   686         TInt position( 1 ); // position 0 is command code

   687         HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

   688         HBufC16* description = ExtractDesLC( aData, position, 1 );

   689         HBufC16* body = ExtractDesLC( aData, position, 2 );

   690         HBufC16* attPath = ExtractDesLC( aData, position, 1 );

   691         TBool isNew = (TBool)aData[position];

   692         TBool isUnread = (TBool)aData[position+1];

   693         TFolder folder = (TFolder)aData[position+2];

   694 

   695         HTI_LOG_TEXT( "Creating SMTP Client MTM" );

   696         CSmtpClientMtm* smtpMtm = NULL;

   697         TRAPD( err, smtpMtm = ( CSmtpClientMtm* )iMtmReg->NewMtmL(

   698                 KUidMsgTypeSMTP ) );

   699         if ( err || !smtpMtm )

   700             {

   701             HTI_LOG_TEXT( "SMTP message type module not found" );

   702             SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

   703             CleanupStack::PopAndDestroy( attPath );

   704             CleanupStack::PopAndDestroy( body );

   705             CleanupStack::PopAndDestroy( description );

   706             CleanupStack::PopAndDestroy( fromTo );

   707             return;

   708             }

   709         CleanupStack::PushL( smtpMtm );

   710 

   711         HTI_LOG_TEXT( "Creating a new CMsvEntry" );

   712         CMsvEntry* entry = CMsvEntry::NewL( *iSession,

   713                                             KMsvGlobalInBoxIndexEntryId,

   714                                             TMsvSelectionOrdering() );

   715         CleanupStack::PushL( entry );

   716 

   717         // get the default service

   718         HTI_LOG_TEXT( "Getting the default service" );

   719         TMsvId defaultServiceId = 0;

   720         TRAP( err, defaultServiceId = smtpMtm->DefaultServiceL() );

   721         if ( err )

   722             {

   723             HTI_LOG_FORMAT( "Could not get default service, err: %d", err );

   724             SendErrorMessageL( err, KErrorMailboxNotDefined );

   725             CleanupStack::PopAndDestroy( entry );

   726             CleanupStack::PopAndDestroy( smtpMtm );

   727             CleanupStack::PopAndDestroy( attPath );

   728             CleanupStack::PopAndDestroy( body );

   729             CleanupStack::PopAndDestroy( description );

   730             CleanupStack::PopAndDestroy( fromTo );

   731             return;

   732             }

   733 

   734         // map the folder parameter to folder id

   735         HTI_LOG_TEXT( "Mapping the folder parameter to folder id" );

   736         TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

   737         TRAP( err, folderId = MapFolderToIdL( folder ) );

   738         if ( err )

   739             {

   740             HTI_LOG_FORMAT( "Invalid folder: %d", folder );

   741             SendErrorMessageL( err, KErrorInvalidFolder );

   742             CleanupStack::PopAndDestroy( entry );

   743             CleanupStack::PopAndDestroy( smtpMtm );

   744             CleanupStack::PopAndDestroy( attPath );

   745             CleanupStack::PopAndDestroy( body );

   746             CleanupStack::PopAndDestroy( description );

   747             CleanupStack::PopAndDestroy( fromTo );

   748             return;

   749             }

   750         entry->SetEntryL( folderId );

   751 

   752         // mtm takes ownership of entry context

   753         smtpMtm->SetCurrentEntryL( entry );

   754         CleanupStack::Pop( entry );

   755 

   756         // create a message and set subject and body

   757         smtpMtm->CreateMessageL( defaultServiceId );

   758         smtpMtm->SetSubjectL( description->Des() );

   759         smtpMtm->Body().Reset();

   760         smtpMtm->Body().InsertL( 0, body->Des() );

   761 

   762         // get the entry of the message

   763         TMsvEntry tentry = smtpMtm->Entry().Entry();

   764 

   765         // add addressee

   766         smtpMtm->AddAddresseeL( fromTo->Des() );

   767         tentry.iDetails.Set( fromTo->Des() );

   768 

   769         // If creating to Inbox use other than KUidMsgTypeSMTP so that the

   770         // mail displays "from" field and not "to" field.

   771         if ( folder == EInbox )

   772             {

   773             tentry.iMtm = KUidMsgTypeIMAP4;

   774             }

   775 

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

   777         tentry.iDescription.Set( description->Des() );

   778 

   779         // save the changes done above

   780         smtpMtm->Entry().ChangeL( tentry );

   781 

   782         // get an access to the message store

   783         CMsvStore* store = entry->EditStoreL();

   784         CleanupStack::PushL( store );

   785         CImHeader* header = CImHeader::NewLC();

   786         header->RestoreL( *store );

   787         TUint charset = header->Charset();

   788         CleanupStack::PopAndDestroy( header );

   789         CleanupStack::PopAndDestroy( store );

   790 

   791         // handle attachment

   792         TBool attachmentsExist = EFalse;

   793         if ( attPath->Length() > 0 )

   794             {

   795             // check that attachment exists

   796             RFs fsSession;

   797             if ( fsSession.Connect() != KErrNone )

   798                 {

   799                 HTI_LOG_FORMAT( "Error in connecting to file server session: %d", err );

   800                 SendErrorMessageL( KErrCouldNotConnect, KErrorRfsConnectFailed );

   801                 CleanupStack::PopAndDestroy( smtpMtm );

   802                 CleanupStack::PopAndDestroy( attPath );

   803                 CleanupStack::PopAndDestroy( body );

   804                 CleanupStack::PopAndDestroy( description );

   805                 CleanupStack::PopAndDestroy( fromTo );

   806                 return;

   807                 }

   808             CleanupClosePushL( fsSession );

   809 

   810             TBool fileExists = BaflUtils::FileExists( fsSession, attPath->Des() );

   811             if ( !fileExists )

   812                 {

   813                 HTI_LOG_TEXT( "Attachment file not found" );

   814                 SendErrorMessageL( KErrPathNotFound, KErrorAttachmentNotFound );

   815                 CleanupStack::PopAndDestroy(); // fsSession

   816                 CleanupStack::PopAndDestroy( smtpMtm );

   817                 CleanupStack::PopAndDestroy( attPath );

   818                 CleanupStack::PopAndDestroy( body );

   819                 CleanupStack::PopAndDestroy( description );

   820                 CleanupStack::PopAndDestroy( fromTo );

   821                 return;

   822                 }

   823             else

   824                 {

   825                 // get the mime type

   826                 HTI_LOG_TEXT( "Getting the attachment's mime type" );

   827                 RApaLsSession ls;

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

   829                 TUid appUid;

   830                 TDataType dataType;

   831                 ls.AppForDocument( *attPath, appUid, dataType );

   832                 TPtrC8 mimeType = dataType.Des8();

   833 

   834                 HTI_LOG_TEXT( "Adding the attachment" );

   835                 CWaiter* waiter = CWaiter::NewLC();

   836                 smtpMtm->AddAttachmentL( attPath->Des(), mimeType, charset,

   837                         waiter->iStatus );

   838                 waiter->StartAndWait();

   839                 CleanupStack::PopAndDestroy( waiter );

   840                 HTI_LOG_TEXT( "Attachment added succesfully" );

   841 

   842                 attachmentsExist = ETrue;

   843                 }

   844 

   845             CleanupStack::PopAndDestroy(); // fsSession

   846             }

   847 

   848         // save the message

   849         smtpMtm->SaveMessageL();

   850 

   851         // final fine tuning

   852         TMsvEmailEntry temailEntry = static_cast<TMsvEmailEntry>( tentry );

   853         temailEntry.SetMessageFolderType( EFolderTypeUnknown );

   854         temailEntry.SetDisconnectedOperation( ENoDisconnectedOperations );

   855         temailEntry.SetEncrypted( EFalse );

   856         temailEntry.SetSigned( EFalse );

   857         temailEntry.SetVCard( EFalse );

   858         temailEntry.SetVCalendar( EFalse );

   859         temailEntry.SetReceipt( EFalse );

   860         temailEntry.SetMHTMLEmail( EFalse );

   861         temailEntry.SetBodyTextComplete( ETrue );

   862         temailEntry.SetAttachment( attachmentsExist );

   863         temailEntry.iDate.UniversalTime();

   864         temailEntry.SetVisible( ETrue );

   865         temailEntry.SetInPreparation( EFalse );

   866         temailEntry.SetSendingState( KMsvSendStateWaiting );

   867         temailEntry.SetUnread( isUnread );

   868         temailEntry.SetNew( isNew );

   869         temailEntry.SetComplete( ETrue );

   870         temailEntry.iServiceId = defaultServiceId;

   871         temailEntry.iRelatedId = 0;

   872 

   873         smtpMtm->Entry().ChangeL( temailEntry );

   874 

   875         // get an access to the message store

   876         store = entry->EditStoreL();

   877         CleanupStack::PushL( store );

   878 

   879         // set email header info

   880         header = CImHeader::NewLC();

   881         header->RestoreL( *store );

   882         header->SetSubjectL( description->Des() );

   883         header->SetFromL( fromTo->Des() );

   884         header->SetReceiptAddressL( fromTo->Des() );

   885         header->StoreL( *store );

   886         store->CommitL();

   887         CleanupStack::PopAndDestroy( header );

   888         CleanupStack::PopAndDestroy( store );

   889 

   890         // send the message, if it is in outbox

   891         if ( folder == EOutbox )

   892             {

   893             HTI_LOG_TEXT( "E-Mail was created in outbox, marking it to be sent on next connection" );

   894 

   895             CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   896             CleanupStack::PushL( selection );

   897             selection->AppendL( temailEntry.Id() );

   898 

   899             TBuf8<1> dummyParameter;

   900             CMsvOperationActiveSchedulerWait* waiter =

   901                     CMsvOperationActiveSchedulerWait::NewLC();

   902             CMsvOperation* op = smtpMtm->InvokeAsyncFunctionL(

   903                     KSMTPMTMSendOnNextConnection, *selection,

   904                     dummyParameter, waiter->iStatus );

   905             CleanupStack::PushL( op );

   906             waiter->Start();

   907             CleanupStack::PopAndDestroy( op );

   908             CleanupStack::PopAndDestroy( waiter );

   909             CleanupStack::PopAndDestroy( selection );

   910             }

   911 

   912         HTI_LOG_TEXT( "Cleaning up" );

   913         CleanupStack::PopAndDestroy( smtpMtm );

   914         CleanupStack::PopAndDestroy( attPath );

   915         CleanupStack::PopAndDestroy( body );

   916         CleanupStack::PopAndDestroy( description );

   917         CleanupStack::PopAndDestroy( fromTo );

   918 

   919         // send the message id back

   920         TInt32 id = tentry.Id();

   921         TBuf8<8> idStr;

   922         idStr.Copy( ( TUint8* )( &id ), sizeof( id ) );

   923         SendOkMsgL( idStr );

   924         }

   925 

   926     HTI_LOG_FUNC_OUT("CMessageMgmntHandler::HandleCreateEmailL: Done");

   927     }

   928 

   929 // ----------------------------------------------------------------------------

   930 void CMessageMgmntHandler::HandleCreateObexMsgL( const TDesC8& aData,

   931                                                  TUid aMtmUid,

   932                                                  TUid aMsgTypeUid )

   933     {

   934     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleCreateObexMsgL" );

   935 

   936     if ( ValidateAddObexMsgCommand( aData ) )

   937         {

   938         // parse the parameters

   939         TInt position( 0 );

   940         HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

   941         HBufC16* description = ExtractDesLC( aData, position, 1 );

   942         HBufC16* attPath = ExtractDesLC( aData, position, 1 );

   943         TBool isNew = (TBool)aData[position];

   944         TBool isUnread = (TBool)aData[position+1];

   945         TFolder folder = (TFolder)aData[position+2];

   946 

   947         // Adding Obex messages to the outbox is not allowed

   948         if ( folder == EOutbox )

   949             {

   950             HTI_LOG_TEXT( "Outbox not supported with Obex messages" );

   951             SendErrorMessageL( KErrNotSupported, KErrorNotSupported );

   952             CleanupStack::PopAndDestroy( attPath );

   953             CleanupStack::PopAndDestroy( description );

   954             CleanupStack::PopAndDestroy( fromTo );

   955             return;

   956             }

   957 

   958         CObexClientMtm* obexMtm = NULL;

   959         TRAPD( err, obexMtm = ( CObexClientMtm* )iMtmReg->NewMtmL( aMtmUid ) );

   960         if ( err || !obexMtm )

   961             {

   962             HTI_LOG_TEXT( "Obex message type module not found" );

   963             SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

   964             CleanupStack::PopAndDestroy( attPath );

   965             CleanupStack::PopAndDestroy( description );

   966             CleanupStack::PopAndDestroy( fromTo );

   967             return;

   968             }

   969         CleanupStack::PushL( obexMtm );

   970 

   971         CMsvEntry* entry = CMsvEntry::NewL( *iSession,

   972                                             KMsvGlobalInBoxIndexEntryId,

   973                                             TMsvSelectionOrdering() );

   974         CleanupStack::PushL( entry );

   975 

   976         TMsvId defaultServiceId = 0;

   977 

   978         // map the folder parameter to folder id

   979         TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

   980         TRAP( err, folderId = MapFolderToIdL( folder ) );

   981         if ( err )

   982             {

   983             HTI_LOG_FORMAT( "Invalid folder: %d", folder );

   984             SendErrorMessageL( err, KErrorInvalidFolder );

   985             CleanupStack::PopAndDestroy( entry );

   986             CleanupStack::PopAndDestroy( obexMtm );

   987             CleanupStack::PopAndDestroy( attPath );

   988             CleanupStack::PopAndDestroy( description );

   989             CleanupStack::PopAndDestroy( fromTo );

   990             return;

   991             }

   992         entry->SetEntryL( folderId );

   993 

   994         // mtm takes ownership of entry context

   995         obexMtm->SetCurrentEntryL( entry );

   996         CleanupStack::Pop( entry );

   997 

   998         // create a new message

   999         obexMtm->CreateMessageL( defaultServiceId );

  1000 

  1001         // get the entry of the message

  1002         TMsvEntry tentry = obexMtm->Entry().Entry();

  1003 

  1004         // set subject

  1005         obexMtm->SetSubjectL( description->Des() );

  1006         tentry.iDescription.Set( description->Des() );

  1007 

  1008         // set body, must be empty for obex messages

  1009         obexMtm->Body().Reset();

  1010 

  1011         // set the details field and

  1012         tentry.iDetails.Set( fromTo->Des() );

  1013 

  1014         // set mtm

  1015         tentry.iMtm = aMtmUid;

  1016         tentry.iType = KUidMsvMessageEntry;

  1017         tentry.iServiceId = KMsvUnknownServiceIndexEntryId;

  1018 

  1019         // save the changes done above

  1020         obexMtm->Entry().ChangeL( tentry );

  1021 

  1022         // save the message

  1023         obexMtm->SaveMessageL();

  1024 

  1025         // final fine tuning

  1026         tentry.iDate.HomeTime();

  1027         tentry.SetVisible( ETrue );

  1028         tentry.SetInPreparation( EFalse );

  1029         tentry.SetUnread( isUnread );

  1030         tentry.SetNew( isNew );

  1031         tentry.SetComplete( ETrue );

  1032         obexMtm->Entry().ChangeL( tentry );

  1033 

  1034         // handle attachment

  1035         if ( attPath->Length() > 0 )

  1036             {

  1037             // check that attachment exists

  1038             RFs fsSession;

  1039             if ( fsSession.Connect() != KErrNone )

  1040                 {

  1041                 HTI_LOG_FORMAT( "Error in connecting to file server session: %d", err );

  1042                 SendErrorMessageL( KErrCouldNotConnect, KErrorRfsConnectFailed );

  1043                 CleanupStack::PopAndDestroy( obexMtm );

  1044                 CleanupStack::PopAndDestroy( attPath );

  1045                 CleanupStack::PopAndDestroy( description );

  1046                 CleanupStack::PopAndDestroy( fromTo );

  1047                 return;

  1048                 }

  1049 

  1050             TBool fileExists = BaflUtils::FileExists( fsSession, attPath->Des() );

  1051             fsSession.Close();

  1052             if ( !fileExists )

  1053                 {

  1054                 HTI_LOG_TEXT( "Attachment file not found" );

  1055                 SendErrorMessageL( KErrPathNotFound, KErrorAttachmentNotFound );

  1056                 CleanupStack::PopAndDestroy( obexMtm );

  1057                 CleanupStack::PopAndDestroy( attPath );

  1058                 CleanupStack::PopAndDestroy( description );

  1059                 CleanupStack::PopAndDestroy( fromTo );

  1060                 return;

  1061                 }

  1062             else

  1063                 {

  1064                 // create a new entry for the attachment

  1065                 TMsvEntry attachTEntry;

  1066                 attachTEntry.iType = KUidMsvAttachmentEntry;

  1067                 attachTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;

  1068                 attachTEntry.iMtm = aMsgTypeUid; //save as bt message

  1069 

  1070                 entry->CreateL( attachTEntry );

  1071 

  1072                 CMsvEntry* attachEntry = iSession->GetEntryL( attachTEntry.Id() );

  1073                 obexMtm->SetCurrentEntryL( attachEntry );

  1074 

  1075                 // get source file

  1076                 TFileName sourceFileName = attPath->Des();

  1077 

  1078                 // get the mime type

  1079                 RApaLsSession ls;

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

  1081                 CleanupClosePushL<RApaLsSession>(ls);

  1082                 TUid appUid;

  1083                 TDataType mimeType;

  1084                 ls.AppForDocument( sourceFileName, appUid, mimeType );

  1085                 CleanupStack::PopAndDestroy(); //ls

  1086 

  1087                 CWaiter* waiter = CWaiter::NewLC();

  1088 

  1089                 // add an attachment to the current message entry

  1090                 obexMtm->AddAttachmentL( sourceFileName, mimeType.Des8(), 0,

  1091                         waiter->iStatus );

  1092                 waiter->StartAndWait();

  1093                 CleanupStack::PopAndDestroy( waiter );

  1094                 }

  1095             }

  1096 

  1097         CleanupStack::PopAndDestroy( obexMtm );

  1098         CleanupStack::PopAndDestroy( attPath );

  1099         CleanupStack::PopAndDestroy( description );

  1100         CleanupStack::PopAndDestroy( fromTo );

  1101 

  1102         // send the message id back

  1103         TInt32 id = tentry.Id();

  1104         TBuf8<8> idStr;

  1105         idStr.Copy( ( TUint8* )( &id ), sizeof( id ) );

  1106         SendOkMsgL( idStr );

  1107         }

  1108 

  1109     HTI_LOG_FUNC_OUT("CMessageMgmntHandler::HandleCreateObexMsgL: Done");

  1110     }

  1111 

  1112 

  1113 // ----------------------------------------------------------------------------

  1114 void CMessageMgmntHandler::HandleCreateSmartMsgL( const TDesC8& aData )

  1115     {

  1116     HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleCreateSmartMsgL" );

  1117 

  1118     if ( ValidateAddSmartMsgCommand( aData ) )

  1119         {

  1120         TInt position( 0 );

  1121         HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

  1122         HBufC16* description = ExtractDesLC( aData, position, 1 );

  1123         HBufC16* body = ExtractDesLC( aData, position, 2 );

  1124         TBool isNew = (TBool)aData[position];

  1125         TBool isUnread = (TBool)aData[position+1];

  1126         TFolder folder = (TFolder)aData[position+2];

  1127         TInt bioUidValue =   aData[position+3] +

  1128                            ( aData[position+4] << 8 ) +

  1129                            ( aData[position+5] << 16 ) +

  1130                            ( aData[position+6] << 24 );

  1131 

  1132 

  1133         // Smart messages can be created only to inbox.

  1134         // For sending smart messages, create a normal SMS with smart message