1 /*

     2 * Copyright (c) 2007-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:  common email object

    15 *

    16 */

    17 

    18 #include <nmcommonheaders.h>

    19 #include "emailtrace.h"

    20 #include <apgcli.h>

    21 #include <apmrec.h>

    22 #include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroy

    23 

    24 //<cmail>

    25 #include "CFSMailMessage.h"

    26 #include "CFSMailPlugin.h"

    27 //</cmail>

    28 #include "CFSMailRequestHandler.h"

    29 #include "CFSMailRequestObserver.h"

    30 

    31 //<qmail>

    32 #include "nmmessage.h"

    33 //</qmail>

    34 

    35 // ================= MEMBER FUNCTIONS ==========================================

    36 

    37 // -----------------------------------------------------------------------------

    38 // CFSMailMessage::NewLC

    39 // -----------------------------------------------------------------------------

    40 EXPORT_C CFSMailMessage * CFSMailMessage::NewLC( TFSMailMsgId aMessageId )

    41 {

    42     FUNC_LOG;

    43     CFSMailMessage* message = new (ELeave) CFSMailMessage();

    44     CleanupStack:: PushL(message);

    45     message->ConstructL( aMessageId );

    46     return message;

    47 } 

    48 

    49 // -----------------------------------------------------------------------------

    50 // CFSMailMessage::NewL

    51 // -----------------------------------------------------------------------------

    52 EXPORT_C CFSMailMessage * CFSMailMessage::NewL( TFSMailMsgId aMessageId )

    53 {

    54     FUNC_LOG;

    55     CFSMailMessage* message =  CFSMailMessage::NewLC(aMessageId);

    56     CleanupStack:: Pop(message);

    57     return message;

    58 }

    59 

    60 // <qmail>

    61 // -----------------------------------------------------------------------------

    62 // CFSMailMessage::NewL

    63 // -----------------------------------------------------------------------------

    64 EXPORT_C CFSMailMessage* CFSMailMessage::NewL( const NmMessage &aMessage )

    65 {

    66     FUNC_LOG;

    67     CFSMailMessage* self = new (ELeave) CFSMailMessage();

    68     CleanupStack::PushL(self);

    69     self->ConstructL(aMessage);

    70     CleanupStack::Pop(self);

    71     return self;

    72 }

    73 // </qmail>

    74 

    75 // -----------------------------------------------------------------------------

    76 // CFSMailMessage::ConstructL

    77 // -----------------------------------------------------------------------------

    78 void CFSMailMessage::ConstructL( TFSMailMsgId aMessageId )

    79 {

    80     FUNC_LOG;

    81     // Base class initialization

    82     CFSMailMessagePart::ConstructL( aMessageId, TFSMailMsgId() );

    83 }

    84 

    85 // <qmail>

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

    87 // CFSMailMessage::ConstructL

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

    89 void CFSMailMessage::ConstructL( const NmMessage &aMessage )

    90 {

    91     FUNC_LOG;

    92     // Base class initialization

    93     

    94     CFSMailMessagePart::ConstructL( aMessage, aMessage.envelope() );

    95 }

    96 // </qmail>

    97 

    98 // -----------------------------------------------------------------------------

    99 // CFSMailMessage::CFSMailMessage

   100 // -----------------------------------------------------------------------------

   101 CFSMailMessage::CFSMailMessage()

   102 {

   103     FUNC_LOG;

   104     // set request handler pointer

   105     iRequestHandler = static_cast<CFSMailRequestHandler*>(Dll::Tls());

   106 }

   107 

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

   109 // CFSMailMessage::~CFSMailMessage

   110 // -----------------------------------------------------------------------------

   111 EXPORT_C CFSMailMessage::~CFSMailMessage()

   112 {

   113     FUNC_LOG;

   114     iMessageBufferForAsyncOp.Reset();

   115 }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CFSMailMessage::SaveMessageL

   119 // -----------------------------------------------------------------------------

   120 EXPORT_C void CFSMailMessage::SaveMessageL()

   121 {

   122     FUNC_LOG;

   123     if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

   124         {

   125         plugin->StoreMessageL(GetMailBoxId(),*this);

   126         }

   127 }

   128 

   129 //<qmail>

   130 // -----------------------------------------------------------------------------

   131 // CFSMailMessage::SaveMessageL

   132 // -----------------------------------------------------------------------------

   133 EXPORT_C TInt CFSMailMessage::SaveMessageL( MFSMailRequestObserver& aOperationObserver )

   134 {

   135     FUNC_LOG;

   136 

   137     CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId());

   138     TFSPendingRequest request = iRequestHandler->InitAsyncRequestL(

   139             GetMessageId().PluginId(), aOperationObserver);

   140     MFSMailRequestObserver* observer = request.iObserver;

   141     if (plugin)

   142         {

   143         iMessageBufferForAsyncOp.Reset();

   144         iMessageBufferForAsyncOp.AppendL(this);

   145         // It saves only message header - notice that iMessageBufferForAsyncOp ownership is not transferred

   146         // to plugin - array contains 'self' pointer so it should not be destroy by plugin

   147         plugin->StoreMessagesL(GetMailBoxId(), iMessageBufferForAsyncOp,

   148                 *observer, request.iRequestId);

   149         }

   150 

   151     return request.iRequestId;

   152 }

   153 //</qmail>

   154 

   155 //<qmail>

   156 // -----------------------------------------------------------------------------

   157 // CFSMailMessage::SaveMessagePartsL

   158 // -----------------------------------------------------------------------------

   159 EXPORT_C TInt CFSMailMessage::SaveMessagePartsL( MFSMailRequestObserver& aOperationObserver )

   160 {

   161     FUNC_LOG;

   162 

   163     RPointerArray<CFSMailMessagePart> messageParts;

   164     CleanupResetAndDestroyPushL(messageParts);

   165 

   166     CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId());

   167     TFSPendingRequest request = iRequestHandler->InitAsyncRequestL(

   168             GetMessageId().PluginId(), aOperationObserver);

   169     MFSMailRequestObserver* observer = request.iObserver;

   170 

   171     //Message part storer can be used to store attachements as well

   172     //AttachmentListL(messageParts);

   173 

   174     CFSMailMessagePart *plainTextPart = PlainTextBodyPartL(EDataSourceLocal);

   175     if (plainTextPart)

   176         {

   177         messageParts.AppendL(plainTextPart);

   178         }

   179     CFSMailMessagePart *htmlPart = HtmlBodyPartL(EDataSourceLocal);

   180     if (htmlPart)

   181         {

   182         messageParts.AppendL(htmlPart);

   183         }

   184 

   185     if (plugin)

   186         {

   187         // Ownership of parts array is transferred to plugin - it will take care about reseting them

   188         plugin->StoreMessagePartsL(messageParts, *observer,

   189                 request.iRequestId);

   190         // message parts array removed from CleanupStack (not destroyed)

   191         CleanupStack::Pop(1, &messageParts);

   192         }

   193     else

   194         {

   195         // message parts array removed from CleanupStack and destroyed

   196         CleanupStack::PopAndDestroy(1, &messageParts);

   197         }

   198 

   199     return request.iRequestId;

   200 }

   201 //<//qmail>

   202 

   203 // -----------------------------------------------------------------------------

   204 // CFSMailMessage::AddNewAttachmentL

   205 // -----------------------------------------------------------------------------

   206 EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( RFile& aFile,

   207                                                                 const TDesC8& aMimeType )

   208 {

   209     FUNC_LOG;

   210     

   211     CFSMailMessagePart* newPart = NULL;

   212     if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

   213         {

   214         TBuf<KMaxDataTypeLength> contentType;

   215         if(aMimeType.Length() > 0)

   216             {

   217             // use user given content type

   218             contentType.Copy(aMimeType);

   219             }

   220         else

   221             {

   222             // try to find out content type using recognizers

   223             RApaLsSession apaSession;

   224             TDataRecognitionResult dataType;

   225             User::LeaveIfError(apaSession.Connect());

   226             User::LeaveIfError(apaSession.RecognizeData(aFile, dataType));

   227             apaSession.Close();

   228             contentType.Copy(dataType.iDataType.Des());

   229             }

   230         

   231         // get file name

   232         TFileName fileName;

   233         aFile.FullName( fileName );

   234 

   235         // get new part from plugin

   236         newPart = plugin->NewChildPartFromFileL(    GetMailBoxId(),

   237                                                     GetFolderId(),

   238                                                     GetMessageId(),

   239                                                     GetPartId(),

   240                                                     contentType,

   241                                                     aFile );

   242         // set attachment name

   243         newPart->SetAttachmentNameL(fileName);

   244 

   245         // store new message part

   246         newPart->SaveL();

   247         

   248         // set flag

   249         SetFlag(EFSMsgFlag_Attachments);

   250         }

   251     return newPart;

   252 }

   253 

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

   255 // CFSMailMessage::AddNewAttachmentL

   256 // -----------------------------------------------------------------------------

   257 EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,

   258                                 const TFSMailMsgId /*aInsertBefore*/ )

   259 {

   260     FUNC_LOG;

   261 

   262     CFSMailMessagePart* newPart = NULL;

   263   

   264     if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

   265         {

   266         // use recognizer to find out ContentType 

   267         RApaLsSession apaSession;

   268         TDataRecognitionResult dataType;

   269         TBufC8<KMaxDataTypeLength> buf;

   270         User::LeaveIfError(apaSession.Connect());

   271         User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));

   272         apaSession.Close();

   273 

   274         // Create new message part with correct Content-Type

   275         TBuf<KMaxDataTypeLength> contentType;

   276         contentType.Copy(dataType.iDataType.Des());

   277         newPart = plugin->NewChildPartFromFileL( GetMailBoxId(),

   278                             GetFolderId(),

   279                             GetMessageId(),

   280                             GetPartId(),

   281                             contentType,

   282                             aFilePath );

   283 

   284     

   285         // Set attachment name

   286         newPart->SetAttachmentNameL(aFilePath);

   287 

   288         // store message part

   289         newPart->SaveL();

   290 

   291         // set flag

   292         SetFlag(EFSMsgFlag_Attachments);

   293     }  

   294     return newPart;

   295 }

   296 

   297 // <qmail>

   298 // -----------------------------------------------------------------------------

   299 // CFSMailMessage::AddNewAttachmentL

   300 // -----------------------------------------------------------------------------

   301 EXPORT_C TInt CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,

   302                                                  MFSMailRequestObserver& aOperationObserver)

   303 {

   304     FUNC_LOG;

   305     TFSPendingRequest request;

   306   

   307     if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

   308         {

   309         // init asynchronous request

   310         request = iRequestHandler->InitAsyncRequestL( GetMessageId().PluginId(),

   311                                                       aOperationObserver );

   312         

   313         MFSMailRequestObserver* observer = request.iObserver;

   314         

   315         // use recognizer to find out ContentType 

   316         RApaLsSession apaSession;

   317         TDataRecognitionResult dataType;

   318         TBufC8<KMaxDataTypeLength> buf;

   319         User::LeaveIfError(apaSession.Connect());

   320         User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));

   321         apaSession.Close();

   322 

   323         // Create new message part with correct Content-Type

   324         TBuf<KMaxDataTypeLength> contentType;

   325         contentType.Copy(dataType.iDataType.Des());

   326 

   327         TRAPD( err, plugin->NewChildPartFromFileL( 

   328             GetMailBoxId(),

   329             GetFolderId(),

   330             GetMessageId(),

   331             GetPartId(),

   332             contentType,

   333             aFilePath,

   334             *observer,

   335             request.iRequestId) );

   336 

   337         if( err != KErrNone )

   338             {

   339             iRequestHandler->CompleteRequest( request.iRequestId );

   340             User::Leave( err );

   341             }

   342         }    

   343     else

   344         {

   345         User::Leave( KErrNotFound );

   346         }

   347 

   348     return request.iRequestId;

   349 }

   350 // </qmail>

   351 

   352 // -----------------------------------------------------------------------------

   353 // CFSMailMessage::AttachmentListL

   354 // -----------------------------------------------------------------------------

   355 EXPORT_C void CFSMailMessage::AttachmentListL(

   356     RPointerArray<CFSMailMessagePart>& aParts )

   357 {

   358     FUNC_LOG;

   359     // First list all message parts

   360     AppendAttachmentsL( aParts ); 

   361 

   362     // special case, if single part content type is not given,

   363     // default type is text/plain

   364     if ( aParts.Count() == 1 && aParts[0]->GetContentType().Length() == 0)

   365         {

   366         aParts.ResetAndDestroy();

   367         }

   368     else

   369         {

   370         // find plain text body part from the list

   371         CFSMailMessagePart* txtPart = FindBodyPartL(KFSMailContentTypeTextPlain);

   372         CleanupStack::PushL( txtPart );

   373         if ( txtPart )

   374             {

   375             // remove plain text body part from attachment list

   376             for ( TInt ii = aParts.Count() - 1; ii >= 0; --ii )

   377                 {

   378                 if ( aParts[ii]->GetPartId() == txtPart->GetPartId() )

   379                     {

   380                     delete aParts[ii];

   381                     aParts.Remove(ii);

   382                     break;

   383                     }

   384                 }

   385             }

   386         CleanupStack::PopAndDestroy( txtPart );

   387 

   388         // find  html body part from the list

   389         CFSMailMessagePart* htmlPart = FindBodyPartL(KFSMailContentTypeTextHtml);

   390         CleanupStack::PushL( htmlPart );

   391         if ( htmlPart )

   392             {

   393             // remove html body part from attachment list

   394             for ( TInt ii = aParts.Count() - 1; ii >= 0; --ii )

   395                 {

   396                 if ( aParts[ii]->GetPartId() == htmlPart->GetPartId() )

   397                     {

   398                     delete aParts[ii];

   399                     aParts.Remove(ii);

   400                     break;

   401                     }

   402                 }

   403             }

   404         CleanupStack::PopAndDestroy( htmlPart );

   405         }

   406 

   407     iMessageParts.ResetAndDestroy();

   408     iReadMessageParts = ETrue;

   409 }

   410 

   411 // -----------------------------------------------------------------------------

   412 // CFSMailMessage::PlainTextBodyPartL

   413 // -----------------------------------------------------------------------------

   414 EXPORT_C CFSMailMessagePart* CFSMailMessage::PlainTextBodyPartL(

   415         TFSMailMessagePartDataSource aDataSource)

   416 {

   417     FUNC_LOG;

   418     CFSMailMessagePart* part = FindBodyPartL(KFSMailContentTypeTextPlain, aDataSource);

   419     

   420     // special case, single part content type is not given

   421     // <qmail>

   422     if(!part && iMessageParts.Count() == 1 && iMessageParts[0]->GetContentType().Length() == 0)

   423     // </qmail>

   424         {

   425         part = iMessageParts[0];

   426         iMessageParts.Remove(0);

   427         }

   428     iMessageParts.ResetAndDestroy();

   429     iReadMessageParts = ETrue;

   430     return part;

   431 }

   432 

   433 // -----------------------------------------------------------------------------

   434 // CFSMailMessage::HtmlBodyPartL

   435 // -----------------------------------------------------------------------------

   436 EXPORT_C CFSMailMessagePart* CFSMailMessage::HtmlBodyPartL(

   437         TFSMailMessagePartDataSource aDataSource)

   438 {

   439     FUNC_LOG;

   440     CFSMailMessagePart* part = FindBodyPartL(KFSMailContentTypeTextHtml, aDataSource);

   441     iMessageParts.ResetAndDestroy();

   442     iReadMessageParts = ETrue;

   443     return part;

   444 }

   445 

   446 // -----------------------------------------------------------------------------

   447 // CFSMailMessage::IsMessageL

   448 // -----------------------------------------------------------------------------

   449 EXPORT_C TBool CFSMailMessage::IsMessageL() const

   450 {

   451     FUNC_LOG;

   452     return CFSMailMessagePart::IsMessageL();

   453 	}

   454 

   455 // -----------------------------------------------------------------------------

   456 // CFSMailMessage::ContentTypeParameters()

   457 // -----------------------------------------------------------------------------

   458 CDesCArray& CFSMailMessage::ContentTypeParameters()

   459 {

   460     FUNC_LOG;

   461     CDesCArray* faked = NULL;

   462     return *faked;

   463 }

   464 

   465 // -----------------------------------------------------------------------------

   466 // CFSMailMessage::DoAttachmentListL

   467 // -----------------------------------------------------------------------------

   468 void CFSMailMessage::DoAttachmentListL( RPointerArray<CFSMailMessagePart>& aParts )

   469 {

   470     FUNC_LOG;

   471     AttachmentListL(aParts);

   472 }

   473 

   474 //<qmail>

   475 // -----------------------------------------------------------------------------

   476 // CFSMailMessage::GetNmMessage

   477 // It does not fill the list of child parts

   478 // -----------------------------------------------------------------------------

   479 EXPORT_C NmMessage* CFSMailMessage::GetNmMessage()

   480 {

   481 	NmMessage* message = new NmMessage(iNmPrivateMessagePart);

   482 	message->setEnvelope(iNmPrivateMessageEnvelope);

   483 	return message;

   484 }

   485 //</qmail>