1 /*

     2 * Copyright (c) 2006 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:  Email interface implementation + utilities.

    15 *

    16 */

    17 

    18 

    19 

    20 //<cmail>

    21 #include "MsgStore.h"

    22 #include "MsgStoreSearchCriteria.h"

    23 #include "MFSMailBoxSearchObserver.h"

    24 //</cmail>

    25 

    26 #include "BasePlugin.h"

    27 #include "BasePluginPanic.h"

    28 #include "baseplugincommonutils.h"

    29 #include "baseplugindelayedopsprivate.h"

    30 

    31 /**

    32  * Base plugin has no particular id.

    33  */

    34 EXPORT_C TUint CBasePlugin::GetPluginId()

    35     {

    36     return 0;

    37     }

    38 

    39 

    40 /**

    41  *

    42  */

    43 EXPORT_C TFSMailBoxStatus CBasePlugin::GetMailBoxStatus(

    44     const TFSMailMsgId& /*aMailBoxId*/ )

    45     {

    46     return EFSMailBoxOnline;

    47     }

    48 

    49 

    50 /**

    51  *

    52  */

    53 EXPORT_C TBool CBasePlugin::MailboxHasCapabilityL(

    54     TFSMailBoxCapabilities /*aCapability*/,

    55     TFSMailMsgId /*aMailBoxId*/ )

    56     {

    57     return EFalse;

    58     }

    59 

    60 

    61 /**

    62  *

    63  */

    64 EXPORT_C TInt CBasePlugin::WizardDataAvailableL()

    65     {

    66     return KErrNotSupported;

    67     }

    68 

    69 

    70 /**

    71  *

    72  */

    73 EXPORT_C void CBasePlugin::AuthenticateL(

    74     MFSMailRequestObserver& /*aOperationObserver*/,

    75     TInt /*aRequestId*/ )

    76     {

    77 

    78     }

    79 

    80 

    81 /**

    82  */

    83 EXPORT_C void CBasePlugin::SetCredentialsL(

    84     const TFSMailMsgId& /* aMailBoxId */,

    85     const TDesC& /* aUsername */,

    86     const TDesC& /* aPassword */ )

    87     {

    88     User::Leave( KErrNotSupported );

    89     }

    90 

    91 

    92 /**

    93  *

    94  */

    95 EXPORT_C TDesC& CBasePlugin::GetBrandingIdL( const TFSMailMsgId& aMailboxId )

    96     {

    97     CMailboxInfo& mailbox = GetMailboxInfoL( aMailboxId.Id() );

    98     return *mailbox.iBrandingId;

    99     }

   100 

   101 

   102 /**

   103  *

   104  */

   105 EXPORT_C TInt CBasePlugin::CancelSyncL( const TFSMailMsgId& /*aMailBoxId*/ )

   106 	{

   107 	return KErrNotSupported;

   108 	}

   109 

   110 

   111 #pragma mark -

   112 #pragma mark ---  SEARCH  ---

   113 

   114 

   115 /**

   116  *

   117  */

   118 class CSearchHandler : public CBase, public MMsgStoreSearchClient

   119     {

   120     public:

   121         CSearchHandler(

   122             MFSMailBoxSearchObserver& aFsObserver,

   123             CBasePlugin& aBasePlugin,

   124             const TFSMailMsgId& aMailBox )

   125             : iFsObserver( aFsObserver ), iBasePlugin( aBasePlugin ), iMailBox( aMailBox )

   126             {

   127             };

   128 

   129         ~CSearchHandler()

   130             {

   131             TRAP_IGNORE( iFsObserver.SearchCompletedL() );

   132             };

   133 

   134     public:

   135         void MatchFound(

   136             CMsgStorePropertyContainer*& aMessageSummary )

   137             {

   138             TRAP_IGNORE( MatchFoundL( aMessageSummary ) );

   139             };

   140 

   141         void MatchFoundL(

   142             CMsgStorePropertyContainer*& aMessageSummary )

   143             {

   144             TFSMailMsgId msgId( iBasePlugin.GetPluginId(), aMessageSummary->Id() );

   145 

   146             CFSMailMessage* fsMsg = CFSMailMessage::NewLC( msgId );

   147 

   148             fsMsg->SetContentType( KNullDesC() );

   149             fsMsg->SetContentDescription( KNullDesC() );

   150             fsMsg->SetContentDisposition( KNullDesC() );

   151             fsMsg->SetMailBoxId( iMailBox );

   152 

   153             iBasePlugin.TranslateMsgStorePropsL( iMailBox, *aMessageSummary, *fsMsg );

   154 

   155             CleanupStack::Pop( fsMsg );

   156             iFsObserver.MatchFoundL( fsMsg );

   157             };

   158 

   159         void SearchCompleted()

   160             {

   161             delete this;

   162             };

   163 

   164     private:

   165         MFSMailBoxSearchObserver& iFsObserver;

   166         CBasePlugin& iBasePlugin;

   167         TFSMailMsgId iMailBox;

   168     };

   169 

   170 

   171 /**

   172  *

   173  */

   174 EXPORT_C void CBasePlugin::SearchL(

   175     const TFSMailMsgId& aMailBoxId,

   176     const RArray<TFSMailMsgId>& aFolderIds,

   177     const RPointerArray<TDesC>& aSearchStrings,

   178     const TFSMailSortCriteria& aSortCriteria,

   179     MFSMailBoxSearchObserver& aSearchObserver )

   180 

   181     {

   182     /**@ search result details?*/

   183 

   184     RMsgStoreSearchCriteria criteria;

   185     CleanupClosePushL( criteria );

   186 

   187     criteria.iSortBy = static_cast<TMsgStoreSortByField>( aSortCriteria.iField - 1 );

   188     criteria.iSortOrder = static_cast<TMsgStoreSortOrder>( aSortCriteria.iOrder );

   189 

   190     TInt count = aSearchStrings.Count();

   191     for ( TInt i = 0; i < count; i++ )

   192         {

   193         criteria.AddSearchStringL( *(aSearchStrings[i]) );

   194         }

   195 

   196     count = aFolderIds.Count();

   197     for ( TInt i = 0; i < count; i++ )

   198         {

   199         criteria.AddFolderId( aFolderIds[i].Id() );

   200         }

   201 

   202     criteria.AddResultPropertyL( KMsgStorePropertyReceivedAt );

   203     criteria.AddResultPropertyL( KMsgStorePropertyFlags );

   204     criteria.AddResultPropertyL( KMsgStorePropertySize );

   205     criteria.AddResultPropertyL( KMsgStorePropertyFrom );

   206     criteria.AddResultPropertyL( KMsgStorePropertySubject );

   207 

   208     /**@ figure the lifecycle mgmnt of the handler.*/

   209     CSearchHandler* searchHandler = new (ELeave) CSearchHandler( aSearchObserver, *this, aMailBoxId );

   210     CleanupStack::PushL( searchHandler );

   211 

   212     CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

   213     mailBox().SearchL( criteria, *searchHandler );

   214 

   215     CleanupStack::Pop( searchHandler );

   216     CleanupStack::PopAndDestroy( &criteria );

   217     }

   218 

   219 

   220 /**

   221  *

   222  */

   223 EXPORT_C void CBasePlugin::CancelSearch(

   224     const TFSMailMsgId& aMailBoxId )

   225 

   226     {

   227     TRAP_IGNORE( DoCancelSearchL( aMailBoxId ) );

   228     }

   229 

   230 

   231 /**

   232  *

   233  */

   234 EXPORT_C void CBasePlugin::ClearSearchResultCache(

   235     const TFSMailMsgId& aMailBoxId )

   236 

   237     {

   238     TRAP_IGNORE( DoClearSearchResultCacheL( aMailBoxId ) );

   239     }

   240 

   241 

   242 #pragma mark --- "MFSMAILPLUGIN - SYNC PLUGIN CONTROL" ---

   243 

   244 

   245 /**

   246  *

   247  */

   248 EXPORT_C void CBasePlugin::GoOfflineL(

   249     const TFSMailMsgId& /*aMailBoxId*/ )

   250     {

   251     }

   252 

   253 

   254 /**

   255  *

   256  */

   257 EXPORT_C void CBasePlugin::GoOnlineL(

   258     const TFSMailMsgId& /*aMailBoxId*/ )

   259     {

   260     }

   261 

   262 

   263 /**

   264  *

   265  */

   266 EXPORT_C void CBasePlugin::RefreshNowL(

   267     const TFSMailMsgId& /*aMailBoxId*/,

   268  	MFSMailRequestObserver& /*aOperationObserver*/,

   269  	TInt /*aRequestId*/ )

   270     {

   271 

   272     }

   273 

   274 

   275 #pragma mark -

   276 #pragma mark --- MRU SUPPORT ---

   277 

   278 

   279 /**

   280  *

   281  */

   282 EXPORT_C MDesCArray* CBasePlugin::GetMrusL(

   283     const TFSMailMsgId& aMailBoxId )

   284 

   285     {

   286     CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

   287 

   288     RPointerArray<CMsgStoreAddress> addressArray;

   289     CleanupResetAndDestroyClosePushL( addressArray );

   290     mailBox().MruAddressesL( addressArray );

   291 

   292     //defione consts to avoid codescanner errors

   293     const TUint KDefaultGranularity = 8;

   294 

   295     TInt granularity = addressArray.Count() > 0 ? 2 * addressArray.Count() : KDefaultGranularity;

   296     CDesCArrayFlat* result = new (ELeave) CDesCArrayFlat( granularity );

   297     CleanupStack::PushL( result );

   298 

   299     TInt count = addressArray.Count();

   300     for ( TInt i = 0; i < count; i++ )

   301         {

   302         result->AppendL( addressArray[i]->DisplayName() );

   303         result->AppendL( addressArray[i]->EmailAddress() );

   304         }

   305 

   306     CleanupStack::Pop( result );

   307     CleanupStack::PopAndDestroy( &addressArray );

   308 

   309     return result;

   310     }

   311 

   312 

   313 /**

   314  *

   315  */

   316 EXPORT_C void CBasePlugin::SetMrusL(

   317     const TFSMailMsgId& aMailBoxId,

   318     MDesCArray* aNewMruList )

   319 

   320     {

   321     CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

   322 

   323     __ASSERT_DEBUG(

   324         0 == ( aNewMruList->MdcaCount() % 2 ),

   325         ::BasePluginPanic( ESetMrusInvalidAssert ) );

   326 

   327     RPointerArray<CMsgStoreAddress> addressArray;

   328     CleanupResetAndDestroyClosePushL( addressArray );

   329 

   330     CMsgStoreAddress* address;

   331     for ( TInt i = 0; i < aNewMruList->MdcaCount(); i+=2 )

   332         {

   333         TPtrC display = aNewMruList->MdcaPoint( i );

   334         TPtrC email = aNewMruList->MdcaPoint( 1 + i );

   335 

   336         address = CMsgStoreAddress::NewL( email, display );

   337         CleanupStack::PushL( address );

   338         addressArray.AppendL( address );

   339         CleanupStack::Pop( address );

   340         }

   341 

   342     mailBox().AddMruAddressesL( addressArray );

   343     CleanupStack::PopAndDestroy( &addressArray );

   344     }

   345 

   346 

   347 #pragma mark --- "MFSMAILPLUGINAPI - STATUS INFO" ---

   348 

   349 

   350 /**

   351  *

   352  */

   353 EXPORT_C TFSProgress CBasePlugin::StatusL( TInt /*aRequestId*/ )

   354     {

   355     TFSProgress result = { TFSProgress::EFSStatus_Waiting, 0, 0, 0 };

   356     return result;

   357     }

   358 

   359 

   360 /**

   361  * Concrete plugins need to call the base plugin's implementation.

   362  * @param aRequestId

   363  */

   364 EXPORT_C void CBasePlugin::CancelL( TInt aRequestId )

   365     {

   366     //find the fetch request and notify the observer.

   367     TInt count = iReqs.Count();

   368     for ( TInt i = 0; i < count; i++ )

   369     	{

   370     	if ( iReqs[i]->iRequestId == aRequestId )

   371     		{

   372     		CFetchRequester* request = iReqs[i];

   373 

   374     		TFSProgress progress;

   375     		progress.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;

   376     		progress.iCounter = progress.iMaxCount = 1;

   377     		progress.iError = KErrNone;

   378     		request->iObserver.RequestResponseL( progress, aRequestId );

   379 

   380     		iReqs.Remove( i );

   381     		delete request;

   382     		break;

   383     		}

   384     	}

   385     }

   386 

   387 

   388 /**

   389  *

   390  */

   391 EXPORT_C const TFSProgress CBasePlugin::GetLastSyncStatusL(

   392     const TFSMailMsgId& /*aMailBoxId*/ )

   393 

   394     {

   395     User::Leave( KErrNotSupported );

   396 

   397     TFSProgress result = { TFSProgress::EFSStatus_Waiting, 0, 0, 0 };

   398     return result;

   399     }

   400 

   401 

   402 /**

   403  *

   404  */

   405 EXPORT_C TSSMailSyncState CBasePlugin::CurrentSyncState(

   406             const TFSMailMsgId& /*aMailboxId*/ )

   407     {

   408     return Idle;

   409     }

   410 

   411 

   412 /**

   413  *

   414  */

   415 EXPORT_C CMsgStoreAccount* CBasePlugin::GetAccountForMsgBoxL(

   416     const TFSMailMsgId& aMailboxId )

   417 

   418     {

   419     CMsgStoreAccount* result = NULL;

   420 

   421     RPointerArray< CMsgStoreAccount > accounts;

   422     iMsgStore->AccountsL( accounts );

   423     CleanupResetAndDestroyClosePushL( accounts );

   424 

   425     TInt count = accounts.Count();

   426     for ( TInt i = 0; i < count; i++ )

   427         {

   428         if ( accounts[i]->Owner() == GetPluginId() )

   429             {

   430             CMsgStoreMailBox* msbox = iMsgStore->OpenAccountL( *accounts[i] );

   431             CleanupStack::PushL( msbox );

   432 

   433             if ( msbox->Id() == aMailboxId.Id() )

   434                 {

   435                 CleanupStack::PopAndDestroy( msbox );

   436                 result = accounts[i];

   437                 accounts.Remove( i );

   438                 break;

   439                 }

   440 

   441             CleanupStack::PopAndDestroy( msbox );

   442             }

   443         }

   444 

   445     CleanupStack::PopAndDestroy( &accounts );

   446 

   447     return result;

   448     }

   449 

   450 /**

   451  *

   452  */

   453 void CBasePlugin::DoCancelSearchL(

   454     const TFSMailMsgId& aMailBoxId )

   455 

   456     {

   457     CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

   458     mailBox().CancelSearch();

   459     }

   460 

   461 void CBasePlugin::DoClearSearchResultCacheL(

   462     const TFSMailMsgId& aMailBoxId )

   463 

   464     {

   465     CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId.Id() );

   466     mailBox().ClearSearchResultCache();

   467     }

   468 

   469 /**

   470  *

   471  */

   472 EXPORT_C /*virtual*/ void CBasePlugin::SetMailboxName(

   473     const TFSMailMsgId& /*aMailboxId*/,

   474     const TDesC& /*aMailboxName*/ )

   475     {

   476     }

   477 

   478 /**

   479  *

   480  */

   481 /*protected*/ EXPORT_C void CBasePlugin::ResetCache()

   482     {

   483     __LOG_ENTER_SUPPRESS( "ResetCache" );

   484 

   485     ResetBodyCache();

   486 

   487     iCacheLine.iMsgChildren.ResetAndDestroy();

   488     iCacheLine.iMsgChildren.Close();

   489 

   490     delete iCacheLine.iMsg;

   491     iCacheLine.iMsg = NULL;

   492 

   493     __LOG_WRITE_INFO( "Reset the base plugin msg and msg parts cache." );

   494     }

   495 

   496 /**

   497  *

   498  */

   499 /*protected*/ EXPORT_C void CBasePlugin::ResetBodyCache()

   500     {

   501     __LOG_ENTER_SUPPRESS( "ResetCache" );

   502     iCacheLine.iBodyChildren.ResetAndDestroy();

   503     iCacheLine.iBodyChildren.Close();

   504 

   505     delete iCacheLine.iBody;

   506     iCacheLine.iBody = NULL;

   507 

   508     __LOG_WRITE_INFO( "Reset the base plugin body and body parts cache." );

   509     }

   510 

   511 /**

   512  *

   513  */

   514 /*protected*/ EXPORT_C CMsgStoreMessage* CBasePlugin::GetCachedMsgL(

   515     TMsgStoreId aMailBoxId,

   516     TMsgStoreId aMsgId )

   517     {

   518     __LOG_ENTER_SUPPRESS( "GetCachedMsgL" );

   519     CMsgStoreMessage* result = NULL;

   520 

   521     if ( iCacheLine.iMsg )

   522         {

   523         if ( aMsgId == iCacheLine.iMsg->Id() )

   524             {

   525             __LOG_WRITE8_FORMAT1_INFO( "Using cached msg, id: 0x%X.", aMsgId );

   526             result = iCacheLine.iMsg;

   527             }

   528         else

   529             {

   530             ResetCache();

   531             }

   532         }

   533 

   534     if ( NULL == result )

   535         {

   536         CMailboxInfo& mailBox = GetMailboxInfoL( aMailBoxId );

   537         iCacheLine.iMsg = mailBox().FetchMessageL( aMsgId, KMsgStoreInvalidId );

   538         result = iCacheLine.iMsg;

   539         }

   540 

   541     return result;

   542     }

   543 

   544 

   545 /**

   546  *

   547  */

   548 /*protected*/

   549 EXPORT_C CMsgStoreMessagePart* CBasePlugin::GetCachedBodyL(

   550     TMsgStoreId aPartId )

   551     {

   552     __LOG_ENTER_SUPPRESS( "GetCachedBodyL" );

   553     __ASSERT_DEBUG( NULL != iCacheLine.iMsg,

   554         BasePluginPanic( EInvalidMsgStoreCacheState ) );

   555 

   556     CMsgStoreMessagePart* result = NULL;

   557 

   558     if ( iCacheLine.iBody && aPartId == iCacheLine.iBody->Id() )

   559         {

   560         __LOG_WRITE8_FORMAT1_INFO(

   561             "Using cached body part, id: 0x%X.", aPartId );

   562         result = iCacheLine.iBody;

   563         }

   564     else

   565         {

   566         ResetBodyCache();

   567         iCacheLine.iBody = iCacheLine.iMsg->ChildPartL( aPartId, ETrue );

   568         }

   569 

   570     return result;

   571     }

   572 

   573 /**

   574  *

   575  */

   576 /*protected*/

   577 EXPORT_C RPointerArray<CMsgStoreMessagePart>& CBasePlugin::GetCachedMsgChildrenL()

   578     {

   579     __LOG_ENTER_SUPPRESS( "GetCachedMsgChildrenL" );

   580 

   581     __ASSERT_DEBUG( NULL != iCacheLine.iMsg,

   582         BasePluginPanic( EInvalidMsgStoreCacheState ) );

   583 

   584     if ( 0 == iCacheLine.iMsgChildren.Count() )

   585         {

   586         iCacheLine.iMsg->ChildPartsL( iCacheLine.iMsgChildren );

   587         }

   588     else

   589         {

   590         __LOG_WRITE8_FORMAT1_INFO( "Using cached msg children, count: %d.",

   591             iCacheLine.iMsgChildren.Count() );

   592         }

   593 

   594     return iCacheLine.iMsgChildren;

   595     }

   596 

   597 /**

   598  *

   599  */

   600 /*protected*/

   601 EXPORT_C RPointerArray<CMsgStoreMessagePart>& CBasePlugin::GetCachedBodyChildrenL()

   602     {

   603     __LOG_ENTER_SUPPRESS( "GetCachedBodyChildrenL" );

   604 

   605     __ASSERT_DEBUG( NULL != iCacheLine.iBody,

   606         BasePluginPanic( EInvalidMsgStoreCacheState ) );

   607 

   608     if ( 0 == iCacheLine.iBodyChildren.Count() )

   609         {

   610         iCacheLine.iBody->ChildPartsL( iCacheLine.iBodyChildren );

   611         }

   612     else

   613         {

   614         __LOG_WRITE8_FORMAT1_INFO( "Using cached body children, count: %d.",

   615             iCacheLine.iBodyChildren.Count() );

   616         }

   617 

   618     return iCacheLine.iBodyChildren;

   619     }

   620 

   621 /**

   622  *

   623  */

   624 /*protected*/ EXPORT_C void CBasePlugin::InvalidateCacheIfNecessary(

   625     TMsgStoreId aId,

   626     TMsgStoreId aParentId,

   627     TMsgStoreId aOtherId )

   628     {

   629     if ( iCacheLine.iMsg )

   630         {

   631         TMsgStoreId id = iCacheLine.iMsg->Id();

   632         if ( aId == id || aParentId == id || aOtherId == id )

   633             {

   634             ResetCache();

   635             }

   636         }

   637     }

   638 

   639 

   640 /**

   641  *

   642  */

   643 /*public*/ EXPORT_C MDelayedOpsManager& CBasePlugin::GetDelayedOpsManager()

   644     {

   645     return *iDelayedOpsManager;

   646     }