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: 

    15 *       POP3 MTM UI

    16 *

    17 */

    18 

    19 

    20 // Standard includes

    21 #include <txtrich.h>                        // CRichText

    22 #include <apacmdln.h>                       // CApaCommandLine

    23 #include <apgcli.h>

    24 #include <apaid.h>

    25 #include <eikdialg.h>                       // CEikDialog

    26 #include <eikon.hrh>

    27 #include <eikenv.h>                         // CEikonEnv

    28 #include <eikrutil.h>                       // EikResourceUtils

    29 #include <aknlistquerydialog.h>

    30 #include <aknPopupHeadingPane.h>            // CAknPopupHeadingPane

    31 #include <ErrorUI.h>                        // CErrorUI

    32 #include <StringLoader.h>

    33 #include <etel.h>                           // KErrEtelBusyDetected

    34 #include <bldvariant.hrh>

    35 #include <etelpckt.h>

    36 

    37 // Messaging includes

    38 #include <mtclreg.h>

    39 #include <mtuireg.h>

    40 #include <mtmuidef.hrh>

    41 #include <pops.h>

    42 #include <pop3set.h>

    43 #include <smtpset.h>

    44 #include <miutset.h>

    45 #include <MuiuMsvProgressReporterOperation.h>

    46 #include <avkon.mbg>                        // bitmaps for progress

    47 #include <MuiuOperationWait.h>

    48 

    49 // Specific includes

    50 #include "ImumPanic.h"

    51 #include <imum.rsg>

    52 #include "Pop3MtmUi.h"

    53 #include <mtmdef.h>

    54 #include <msvids.h>

    55 #include "PROGTYPE.H"

    56 #include "MsvEmailConnectionProgressProvider.h"

    57 #include "EmailUtils.H"

    58 #include "EmailFeatureUtils.h"

    59 #include <muiuflagger.h>                    // CMuiuFlags

    60 #include "ImumDisconnectOperation.h"

    61 #include "ImumEditOperation.h"

    62 #include "ImumFetchAndEditOperation.h"

    63 #include <MTMStore.h>

    64 #include "ImumOnlineOperation.h"

    65 #include "ImumDeleteMessagesLocally.h"

    66 #include "ImumDeleteMessagesFromServer.h"

    67 #include "MsvPop3ConnectOp.h"

    68 #include "MsvPop3FetchOperation.h"

    69 #include "MsvPop3CopyMoveOperation.h"

    70 #include <MtmExtendedCapabilities.hrh>

    71 #include <Muiumsginfo.h>

    72 #include <Muiumsginfo.hrh>

    73 #include "EmailEditorViewerUids.h"

    74 #include <aknnotewrappers.h>                // CAknNoteDialog

    75 #include "IMSSettingsNoteUi.h"

    76 #include <ImumInternalApi.h>        // CImumInternalApi

    77 #include <ImumInHealthServices.h>

    78 #include "ImumMtmLogging.h"

    79 #include "ImumListQueryDialog.h"

    80 

    81 // prevents warning with TRefByValue in WINS REL

    82 #pragma warning (disable : 4710)	// CSI: 47 # Needed for disable warning.

    83 

    84 // Constants

    85 const TInt KPop3MtmUiDeleteMessagesLocally = 0;

    86 const TInt KImumEntriesDoneReplaceIndex = 0;

    87 const TInt KImumTotalEntriesReplaceIndex = 1;

    88 // Convenience function IDs for FetchL().

    89 const TInt KFunctionIdFetchSelected = KPOP3MTMCopyMailSelectionWhenAlreadyConnected;

    90 const TInt KFunctionIdFetchAll = KPOP3MTMCopyAllMailWhenAlreadyConnected;

    91 const TInt KFunctionIdFetchNew = KPOP3MTMCopyNewMailWhenAlreadyConnected;

    92 const TInt KImumMessageInfoDateBufferLength = 30;

    93 const TInt KImumMessageInfoSizeBufferLength = 20;

    94 const TInt KImumMessagePriorityBufferLength = 32;

    95 const TInt KImumMaxCharsInLine = 75;

    96 const TInt KImumKB = 1024;

    97 const TInt KErrDndNameNotFound = -5120;

    98 

    99 // Defines

   100 _LIT( KPop3uMtmUiResourceFile, "imum.rsc" );

   101 

   102 //////////////////////

   103 // Factory function //

   104 //////////////////////

   105 

   106 // ----------------------------------------------------------------------------

   107 // NewPP3UMtmUiL()

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

   109 //

   110 EXPORT_C CBaseMtmUi* NewPP3UMtmUiL(CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll)

   111     {

   112     return CPop3MtmUi::NewL(aMtm, aRegisteredDll);

   113     }

   114 

   115 // ----------------------------------------------------------------------------

   116 // CPop3MtmUi::NewL()

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

   118 //

   119 CPop3MtmUi* CPop3MtmUi::NewL(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

   120     {

   121     IMUM_STATIC_CONTEXT( CPop3MtmUi::NewL, 0, mtm, KImumMtmLog );

   122     IMUM_IN();

   123     

   124     CPop3MtmUi* self=new(ELeave) CPop3MtmUi(aBaseMtm, aRegisteredMtmDll);

   125     CleanupStack::PushL(self);

   126     self->ConstructL();

   127     CleanupStack::Pop();

   128     

   129     IMUM_OUT();

   130     

   131     return self;

   132     }

   133 

   134 // ----------------------------------------------------------------------------

   135 // CPop3MtmUi::CPop3MtmUi(()

   136 // ----------------------------------------------------------------------------

   137 //

   138 CPop3MtmUi::CPop3MtmUi(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

   139     :

   140     CImumMtmBaseMtmUi(aBaseMtm, aRegisteredMtmDll)

   141     {

   142     IMUM_CONTEXT( CPop3MtmUi::CPop3MtmUi, 0, KImumMtmLog );

   143     IMUM_IN();

   144     

   145     IMUM_OUT();

   146     }

   147 

   148 // ----------------------------------------------------------------------------

   149 // CPop3MtmUi::ConstructL()

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

   151 //

   152 void CPop3MtmUi::ConstructL()

   153     {

   154     IMUM_CONTEXT( CPop3MtmUi::ConstructL, 0, KImumMtmLog );

   155     IMUM_IN();

   156     

   157     // --- Make sure base class correctly constructed ---

   158     CImumMtmBaseMtmUi::ConstructL();

   159     iServerNameCache.iService = KMsvNullIndexEntryId;

   160     IMUM_OUT();

   161     }

   162 

   163 // ----------------------------------------------------------------------------

   164 // CPop3MtmUi::GetEditorFileNameL()

   165 // ----------------------------------------------------------------------------

   166 //

   167 HBufC* CPop3MtmUi::GetEditorFileNameL()

   168     {

   169     IMUM_CONTEXT( CPop3MtmUi::GetEditorFileNameL, 0, KImumMtmLog );

   170     IMUM_IN();

   171     

   172     if(!iEditorFilename)

   173         {

   174         iEditorFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

   175             KUidMsgInternetMailEditor);

   176         }

   177     IMUM_OUT();

   178     return iEditorFilename;

   179     }

   180 

   181 // ----------------------------------------------------------------------------

   182 // CPop3MtmUi::GetViewerFileNameL()

   183 // ----------------------------------------------------------------------------

   184 //

   185 HBufC* CPop3MtmUi::GetViewerFileNameL()

   186     {

   187     IMUM_CONTEXT( CPop3MtmUi::GetViewerFileNameL, 0, KImumMtmLog );

   188     IMUM_IN();

   189     

   190     if(!iViewerFilename)

   191         {

   192         iViewerFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

   193             KUidMsgInternetMailViewer);

   194         }

   195     IMUM_OUT();

   196     return iViewerFilename;

   197     }

   198 

   199 // ----------------------------------------------------------------------------

   200 // ::~CPop3MtmUi()()

   201 // ----------------------------------------------------------------------------

   202 //

   203 CPop3MtmUi::~CPop3MtmUi()

   204     {

   205     IMUM_CONTEXT( CPop3MtmUi::~CPop3MtmUi, 0, KImumMtmLog );

   206     IMUM_IN();

   207     

   208     delete iEditorFilename;

   209     delete iViewerFilename;

   210     IMUM_OUT();

   211     }

   212 

   213 // ----------------------------------------------------------------------------

   214 // CPop3MtmUi::CreateL()

   215 // ----------------------------------------------------------------------------

   216 //

   217 CMsvOperation* CPop3MtmUi::CreateL(

   218     const TMsvEntry& aEntry,

   219     CMsvEntry& aParent,

   220     TRequestStatus& aStatus)

   221     {

   222     IMUM_CONTEXT( CPop3MtmUi::CreateL, 0, KImumMtmLog );

   223     IMUM_IN();

   224     

   225     // Context is irrelevant.

   226     aStatus=KRequestPending;

   227     // Make sure the entry is a service, since POP3 doesn't support folders

   228     // and POP3 messages / attachments are only created by the engine components

   229     if (aEntry.iType.iUid!=KUidMsvServiceEntryValue)

   230         User::Leave(KErrNotSupported);

   231     //

   232     // Since services can only be created from the root, make sure the requested parent is root

   233     __ASSERT_ALWAYS(aParent.Entry().Id()==KMsvRootIndexEntryId, User::Panic(KImumMtmUiPanic, EPop3MtmUiParentNotRoot));

   234     //

   235     // Create an SMTP service entry

   236     TMsvEntry smtpService(aEntry);

   237     smtpService.iMtm=KUidMsgTypeSMTP;

   238     smtpService.SetVisible(EFalse);

   239     aParent.CreateL(smtpService);

   240     IMUM_OUT();

   241     //

   242     // POP3 MTMUI defers set-up to the SMTP MTMUI, so create an SMTP mtmui and edit a service with it

   243     return EditSmtpServiceL(aStatus, smtpService.Id());

   244     }

   245 

   246 // ----------------------------------------------------------------------------

   247 // CPop3MtmUi::OpenL()

   248 // ----------------------------------------------------------------------------

   249 //

   250 CMsvOperation* CPop3MtmUi::OpenL(TRequestStatus& aStatus)

   251     {

   252     IMUM_CONTEXT( CPop3MtmUi::OpenL, 0, KImumMtmLog );

   253     IMUM_IN();

   254     

   255     // Context is the entry to open.

   256     const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

   257     CheckEntryL(contextEntry);

   258 

   259     if(contextEntry.iType.iUid == KUidMsvMessageEntryValue)

   260         {

   261         IMUM_OUT();

   262         return EditL(aStatus);

   263         }

   264 

   265     // Entry is a service.

   266     /*Check if partial fetch should be used*/

   267     /*

   268     const TMsvId serviceId = contextEntry.Id();

   269     const CImPop3Settings& settings = GetAccountSettingsL(serviceId);

   270     TInt limit = settings.PopulationLimit();

   271 

   272     TInt functionID = KPOP3MTMConnect;

   273     // n lines of message to be fetched. or full message.

   274     if( limit == EFullBody || ( limit >= EUserDefinedKB && limit < KMaxTInt32 ) )

   275         {

   276         functionID = KPOP3MTMPopulateAll;

   277         }

   278         */

   279 

   280     TBuf8<1> dummyParams;

   281     dummyParams.Zero();

   282     CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;

   283     CleanupStack::PushL(sel);

   284     sel->AppendL(contextEntry.Id());

   285 

   286     CMsvOperation* op = InvokeAsyncFunctionL(

   287         KPOP3MTMConnect, *sel, aStatus, dummyParams);

   288     CleanupStack::PopAndDestroy();//sel

   289     IMUM_OUT();

   290     return op;

   291     }

   292 

   293 // ----------------------------------------------------------------------------

   294 // CPop3MtmUi::OpenL()

   295 // ----------------------------------------------------------------------------

   296 //

   297 CMsvOperation* CPop3MtmUi::OpenL(

   298     TRequestStatus& aStatus,

   299     const CMsvEntrySelection& aSelection)

   300     {

   301     IMUM_CONTEXT( CPop3MtmUi::OpenL, 0, KImumMtmLog );

   302     IMUM_IN();

   303     

   304     // Context is irrelevant.

   305     TMsvId selectionParent=KMsvNullIndexEntryId;

   306     CheckSelectionL(aSelection, selectionParent);

   307     // Edit the message selection

   308     IMUM_OUT();

   309     return EditL(aStatus, aSelection);

   310     }

   311 

   312 // ----------------------------------------------------------------------------

   313 // CPop3MtmUi::CloseL()

   314 // ----------------------------------------------------------------------------

   315 //

   316 CMsvOperation* CPop3MtmUi::CloseL(TRequestStatus& aStatus)

   317     {

   318     IMUM_CONTEXT( CPop3MtmUi::CloseL, 0, KImumMtmLog );

   319     IMUM_IN();

   320     

   321     // Context is the entry to close.

   322     const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

   323     CheckEntryL(contextEntry);

   324     // Check that current context is a service, all other entry types

   325     // cannot be closed

   326     if(contextEntry.iType != KUidMsvServiceEntry)

   327         {

   328         User::Leave(KErrNotSupported);

   329         }

   330     // Disconnect the service

   331     aStatus=KRequestPending;

   332     if(Session().ServiceActive(contextEntry.Id()))

   333         {

   334         IMUM_OUT();

   335         // Service is busy

   336         return CMsvCompletedOperation::NewL(

   337             Session(),

   338             Type(),

   339             KNullDesC8,

   340             KMsvLocalServiceIndexEntryId,

   341             aStatus,

   342             KErrNone);// KErrNone because we've reported the fact to the user

   343         }

   344     CMsvEntrySelection* sel=SingleEntrySelectionLC(contextEntry.Id());

   345     TBuf8<1> buf;

   346     buf.Zero();

   347     CMsvOperation* op=InvokeAsyncFunctionL(KPOP3MTMDisconnect, *sel, aStatus, buf);

   348     CleanupStack::PopAndDestroy();//selection

   349     IMUM_OUT();

   350     return op;

   351     }

   352 

   353 // ----------------------------------------------------------------------------

   354 // CPop3MtmUi::CloseL()

   355 // ----------------------------------------------------------------------------

   356 //

   357 CMsvOperation* CPop3MtmUi::CloseL(

   358     TRequestStatus& /*aStatus*/,

   359     const CMsvEntrySelection& /*aSelection*/)

   360     {

   361     IMUM_CONTEXT( CPop3MtmUi::CloseL, 0, KImumMtmLog );

   362     IMUM_IN();

   363     

   364     // Multiple close is not supported

   365     User::Leave(KErrNotSupported);

   366     IMUM_OUT();

   367     return NULL;

   368     }

   369 

   370 // ----------------------------------------------------------------------------

   371 // CPop3MtmUi::EditL()

   372 // ----------------------------------------------------------------------------

   373 //

   374 CMsvOperation* CPop3MtmUi::EditL(TRequestStatus& aStatus)

   375     {

   376     IMUM_CONTEXT( CPop3MtmUi::EditL, 0, KImumMtmLog );

   377     IMUM_IN();

   378     

   379     // Context is the entry to edit.

   380     const TMsvEntry& contextEntry=BaseMtm().Entry().Entry();

   381     CheckEntryL(contextEntry);

   382 

   383     // Edit service (mailbox)

   384     if(contextEntry.iType.iUid==KUidMsvServiceEntryValue)

   385         {

   386         TMsvEntry mailbox = BaseMtm().Entry().Entry();

   387         if ( !iMailboxApi->HealthServicesL().IsMailboxHealthy( mailbox.Id() ) )

   388             {

   389             User::Leave( KErrNotFound );

   390             }    

   391         

   392         return EditSmtpServiceL(aStatus, mailbox.iRelatedId);

   393         }

   394     IMUM_OUT();

   395     // Edit message

   396     return ViewMessageL(aStatus);

   397     // POP3 messages are always read only, so actually we are viewing the message.

   398     }

   399 

   400 // ----------------------------------------------------------------------------

   401 // CPop3MtmUi::EditL()

   402 // ----------------------------------------------------------------------------

   403 //

   404 CMsvOperation* CPop3MtmUi::EditL(

   405     TRequestStatus& aStatus,

   406     const CMsvEntrySelection& aSelection)

   407     {

   408     IMUM_CONTEXT( CPop3MtmUi::EditL, 0, KImumMtmLog );

   409     IMUM_IN();

   410     

   411     // Context is irrelevant.

   412     // Only the first message in the selection is editted.

   413     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, EPop3MtmUiSelectionIsEmpty));

   414     BaseMtm().Entry().SetEntryL(aSelection[0]);

   415     IMUM_OUT();

   416     return EditL(aStatus);

   417     }

   418 

   419 // ----------------------------------------------------------------------------

   420 // CPop3MtmUi::ViewL()

   421 // ----------------------------------------------------------------------------

   422 //

   423 CMsvOperation* CPop3MtmUi::ViewL(TRequestStatus& aStatus)

   424     {

   425     IMUM_CONTEXT( CPop3MtmUi::ViewL, 0, KImumMtmLog );

   426     IMUM_IN();

   427     

   428     // Context is the message to view.

   429     const TMsvEntry& context=BaseMtm().Entry().Entry();

   430     CheckEntryL(context);

   431 

   432     // Can only view message entries

   433     if(context.iType.iUid != KUidMsvMessageEntryValue)

   434         {

   435         User::Leave(KErrNotSupported);

   436         }

   437     IMUM_OUT();

   438 

   439     return ViewMessageL(aStatus);

   440     }

   441 

   442 // ----------------------------------------------------------------------------

   443 // CPop3MtmUi::ViewL()

   444 // ----------------------------------------------------------------------------

   445 //

   446 CMsvOperation* CPop3MtmUi::ViewL(

   447     TRequestStatus& aStatus,

   448     const CMsvEntrySelection& aSelection)

   449     {

   450     IMUM_CONTEXT( CPop3MtmUi::ViewL, 0, KImumMtmLog );

   451     IMUM_IN();

   452     

   453     // Context is irrelevant.

   454     // Only the first message in the selection is viewed.

   455     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, EPop3MtmUiSelectionIsEmpty));

   456     BaseMtm().Entry().SetEntryL(aSelection[0]);

   457     IMUM_OUT();

   458     return ViewL(aStatus);

   459     }

   460 

   461 // ----------------------------------------------------------------------------

   462 // CPop3MtmUi::CancelL()

   463 // ----------------------------------------------------------------------------

   464 //

   465 CMsvOperation* CPop3MtmUi::CancelL(

   466     TRequestStatus& /*aStatus*/,

   467     const CMsvEntrySelection& /*aSelection*/)

   468     {

   469     IMUM_CONTEXT( CPop3MtmUi::CancelL, 0, KImumMtmLog );

   470     IMUM_IN();

   471     

   472     // Currently this function only used to suspend messages queued for sending.

   473     // Can't send POP3 messages, so can't cancel them either.

   474     User::Leave(KErrNotSupported);

   475     IMUM_OUT();

   476     return NULL;

   477     }

   478 

   479 // ----------------------------------------------------------------------------

   480 // CPop3MtmUi::CopyToL()

   481 // ----------------------------------------------------------------------------

   482 //

   483 CMsvOperation* CPop3MtmUi::CopyToL(

   484     const CMsvEntrySelection& /*aSelection*/,

   485     TRequestStatus& /*aStatus*/)

   486     {

   487     IMUM_CONTEXT( CPop3MtmUi::CopyToL, 0, KImumMtmLog );

   488     IMUM_IN();

   489     

   490     __ASSERT_DEBUG( EFalse, User::Panic(KImumMtmUiPanic, EPop3MtmUiCannotCopyOrMoveToRemote));

   491     User::Leave(KErrNotSupported);

   492     IMUM_OUT();

   493     return NULL;

   494     }

   495 

   496 // ----------------------------------------------------------------------------

   497 // CPop3MtmUi::MoveToL()

   498 // ----------------------------------------------------------------------------

   499 //

   500 CMsvOperation* CPop3MtmUi::MoveToL(

   501     const CMsvEntrySelection& /*aSelection*/,

   502     TRequestStatus& /*aStatus*/)

   503     {

   504     IMUM_CONTEXT( CPop3MtmUi::MoveToL, 0, KImumMtmLog );

   505     IMUM_IN();

   506     

   507     __ASSERT_DEBUG( EFalse, User::Panic(KImumMtmUiPanic, EPop3MtmUiCannotCopyOrMoveToRemote));

   508     User::Leave(KErrNotSupported);

   509     IMUM_OUT();

   510     return NULL;

   511     }

   512 

   513 // ----------------------------------------------------------------------------

   514 // CPop3MtmUi::CopyFromL()

   515 // ----------------------------------------------------------------------------

   516 //

   517 CMsvOperation* CPop3MtmUi::CopyFromL(

   518     const CMsvEntrySelection& /*aSelection*/,

   519     TMsvId /*aTargetId*/,

   520     TRequestStatus& /*aStatus*/ )

   521     {

   522     IMUM_CONTEXT( CPop3MtmUi::CopyFromL, 0, KImumMtmLog );

   523     IMUM_IN();

   524     

   525     User::Leave( KErrNotSupported );

   526     IMUM_OUT();

   527     return NULL;

   528     }

   529 

   530 // ----------------------------------------------------------------------------

   531 // CPop3MtmUi::MoveFromL()

   532 // ----------------------------------------------------------------------------

   533 //

   534 CMsvOperation* CPop3MtmUi::MoveFromL(

   535     const CMsvEntrySelection& /*aSelection*/,

   536     TMsvId /*aTargetId*/,

   537     TRequestStatus& /*aStatus*/)

   538     {

   539     IMUM_CONTEXT( CPop3MtmUi::MoveFromL, 0, KImumMtmLog );

   540     IMUM_IN();

   541     

   542     User::Leave(KErrNotSupported);

   543     IMUM_OUT();

   544     return NULL;

   545     }

   546 

   547 // ----------------------------------------------------------------------------

   548 // ::QueryCapability(()

   549 // ----------------------------------------------------------------------------

   550 //

   551 TInt CPop3MtmUi::QueryCapability(TUid aCapability, TInt& aResponse)

   552     {

   553     IMUM_CONTEXT( CPop3MtmUi::QueryCapability, 0, KImumMtmLog );

   554     IMUM_IN();

   555     

   556     switch (aCapability.iUid)

   557         {

   558     case KUidMsvMtmUiQueryConnectionOrientedServices:

   559         IMUM_OUT();

   560         return KErrNone;

   561 

   562     default:

   563         break;

   564         };

   565 

   566     IMUM_OUT();

   567     return CBaseMtmUi::QueryCapability(aCapability, aResponse);

   568     }

   569 

   570 // ----------------------------------------------------------------------------

   571 // CPop3MtmUi::InvokeAsyncFunctionL()

   572 // ----------------------------------------------------------------------------

   573 //

   574 CMsvOperation* CPop3MtmUi::InvokeAsyncFunctionL(

   575     TInt aFunctionId,

   576     const CMsvEntrySelection& aSelection,

   577     TRequestStatus& aStatus,

   578     TDes8& aParameter )

   579     {

   580     IMUM_CONTEXT( CPop3MtmUi::InvokeAsyncFunctionL, 0, KImumMtmLog );

   581     IMUM_IN();

   582     

   583     // Context is dependant upon function ID.

   584     CMsvOperation* op = NULL;

   585 

   586     TMsvEntry tEntry;

   587     TMsvId service;

   588     Session().GetEntry( BaseMtm().Entry().EntryId(), service, tEntry );

   589     //Offline checks VARIATION START

   590     if( iFeatureFlags->GF( EMailFeatureOfflineMode ) &&

   591          aFunctionId != KMtmUiFunctionMessageInfo)

   592         {

   593         TBool offline = EFalse;

   594 

   595         TMsvEntry tEntry;

   596         TMsvId service;

   597         Session().GetEntry( BaseMtm().Entry().EntryId(), service, tEntry );

   598         if( !tEntry.Connected() &&

   599             !iMailboxApi->MailboxUtilitiesL().HasWlanConnectionL( service ) )            

   600             {

   601             offline = MsvEmailMtmUiUtils::DoOfflineChecksL( service );

   602             }

   603 

   604         if( offline )

   605             {

   606             op = CMsvCompletedOperation::NewL(

   607                 Session(), Type(), KNullDesC8,

   608                 KMsvLocalServiceIndexEntryId, aStatus, KErrCancel );

   609             return op;

   610             }

   611         }//if

   612     //VARIATION END

   613 

   614     switch( aFunctionId )

   615         {

   616         case KMtmUiFunctionFetchAll:

   617             IMUM_OUT();

   618             // Client MTM context is service.

   619             return FetchL( aStatus, aSelection, KFunctionIdFetchAll );

   620 

   621         case KMtmUiFunctionFetchNew:

   622             IMUM_OUT();

   623             // Client MTM context is service.

   624             return FetchL( aStatus, aSelection, KFunctionIdFetchNew );

   625 

   626         case KMtmUiFunctionFetchSelected:

   627             {

   628             // Client MTM context is service

   629             // Check there is something to fetch.

   630             CMsvEntrySelection* entries =

   631                 MsvEmailMtmUiUtils::StripCompleteEntriesLC(

   632                 BaseMtm().Entry(), aSelection );

   633             const TInt count = entries->Count();

   634             CleanupStack::PopAndDestroy();  // entries

   635             if( !count )

   636                 {

   637                 IMUM_OUT();

   638                 // All messages are complete so nothing to do.

   639                 return CMsvCompletedOperation::NewL(

   640                     Session(),

   641                     Type(),

   642                     KNullDesC8,

   643                     KMsvLocalServiceIndexEntryId,

   644                     aStatus,

   645                     KErrNone);

   646                 }

   647             }

   648             return FetchL( aStatus, aSelection, KFunctionIdFetchSelected );

   649 

   650         case KMtmUiFunctionGetNew:

   651             IMUM_OUT();

   652             // Client MTM context is service.

   653             return GetMailL( aStatus );

   654 

   655         case KPOP3MTMConnect:

   656         case KPOP3MTMDisconnect:

   657             {

   658 

   659             const CImPop3Settings& settings = GetAccountSettingsL( service );

   660 

   661             //get population limit for connect operations

   662             TInt limit = settings.PopulationLimit();

   663             // -1 means body and attachment, pass it to Symbian mail engine

   664             if ( limit != -1 )

   665                 {

   666                 limit = ( limit * KImumKB ) / KImumMaxCharsInLine;

   667                 }

   668 

   669             // Context is irrelevant.

   670             // aSelection[0] is service ID.

   671             CMsvProgressReporterOperation* reporter =

   672                 CMsvProgressReporterOperation::NewL(

   673                     ETrue, ETrue, Session(),

   674                     aStatus, EMbmAvkonQgn_note_progress );

   675             CleanupStack::PushL( reporter );

   676             if( aFunctionId == KPOP3MTMConnect )

   677                 {

   678                 op = CMsvPop3ConnectOp::NewL(

   679                     reporter->RequestStatus(),

   680                     *reporter,

   681                     aSelection[ 0 ],

   682                     limit );

   683                 TBuf<EProgressStringMaxLen> buffer;

   684                 FormatConnectingServerProgressTextL( service, buffer );

   685                 reporter->SetTitleL( buffer );

   686                 reporter->SetSeeding( ETrue );

   687                 }

   688             else

   689                 {

   690                 op = CImumDisconnectOperation::NewL(

   691                     *iMailboxApi,

   692                     reporter->RequestStatus(),

   693                     *reporter,

   694                     aSelection[ 0 ],

   695                     KPOP3MTMDisconnect,

   696                     KUidMsgTypePOP3 );

   697                 }

   698             reporter->SetOperationL( op ); // Takes immediate ownership

   699             CleanupStack::Pop(); // reporter

   700             IMUM_OUT();

   701             return reporter;

   702 

   703             }

   704         case KMtmUiFunctionMessageInfo:

   705             IMUM_OUT();

   706             return ShowMessageInfoL( aStatus, aParameter );

   707             /*

   708         case KPOP3MTMPopulateAll:

   709             {

   710             //doing full partial fetch instead of bare connect

   711             return FetchL(aStatus, aSelection, KPOP3MTMPopulateAll);

   712             }

   713             break;

   714             */

   715         default:

   716             break;

   717         };

   718     IMUM_OUT();

   719 

   720     return CBaseMtmUi::InvokeAsyncFunctionL(

   721         aFunctionId, aSelection, aStatus, aParameter );

   722     }

   723 

   724 // ----------------------------------------------------------------------------

   725 // CPop3MtmUi::ShowMessageInfoL()

   726 // ----------------------------------------------------------------------------

   727 //

   728 CMsvOperation* CPop3MtmUi::ShowMessageInfoL(

   729     TRequestStatus& aCompletionStatus,

   730     TDes8& /*aParameter*/)

   731     {

   732     IMUM_CONTEXT( CPop3MtmUi::ShowMessageInfoL, 0, KImumMtmLog );

   733     IMUM_IN();

   734     

   735     TMsgInfoMessageInfoData infoData;

   736     TBuf<KImumMessageInfoDateBufferLength> dateBuf;

   737     TBuf<KImumMessageInfoDateBufferLength> timeBuf;

   738     TBuf<KImumMessageInfoSizeBufferLength> sizeBuf;

   739     TBuf<KImumMessagePriorityBufferLength> priorityBuf;

   740     TBool readStoreFound = MsvEmailMtmUiUtils::SetMessageInfoDataLCC(

   741         infoData,BaseMtm(),*iEikonEnv,dateBuf,timeBuf,sizeBuf,priorityBuf);

   742 

   743     TBuf<KImumMessageInfoDateBufferLength> type;

   744     iEikonEnv->ReadResourceL(type,R_POP3_MESSAGE_INFO_MAIL_TYPE);

   745     infoData.iType.Set(type);

   746 

   747     CMsgInfoMessageInfoDialog* infoDialog = CMsgInfoMessageInfoDialog::NewL();

   748     infoDialog->ExecuteLD(infoData,CMsgInfoMessageInfoDialog::EEmailViewer);

   749     CleanupStack::PopAndDestroy(2); // CSI: 47 # 2 because SetMessageInfoDataLCC

   750     if ( readStoreFound )

   751         {

   752         CleanupStack::PopAndDestroy(2); // CSI: 47 # 2 because store found

   753         }

   754     IMUM_OUT();

   755 

   756     return CMsvCompletedOperation::NewL(

   757         Session(),

   758         KUidMsvLocalServiceMtm,

   759         KNullDesC8,

   760         KMsvLocalServiceIndexEntryId,

   761         aCompletionStatus,

   762         KErrNone);

   763     }

   764 

   765 // ----------------------------------------------------------------------------

   766 // CPop3MtmUi::FetchSyncL()

   767 // Offer to fetch messages synchronously if not downloaded.

   768 // ----------------------------------------------------------------------------

   769 //

   770 TInt CPop3MtmUi::FetchSyncL(const CMsvEntrySelection& aSelection)

   771     {

   772     IMUM_CONTEXT( CPop3MtmUi::FetchSyncL, 0, KImumMtmLog );

   773     IMUM_IN();

   774     

   775     // Client context is irrelevant.

   776     TMsvId parent = KMsvNullIndexEntryId;

   777     CheckSelectionL(aSelection, parent);

   778     BaseMtm().SwitchCurrentEntryL(parent);

   779     CMsvEntry* clientContext = &(BaseMtm().Entry());

   780     CMsvEntrySelection* entries = MsvEmailMtmUiUtils::StripCompleteEntriesLC(*clientContext, aSelection);

   781     const TInt count = entries->Count();

   782     CleanupStack::PopAndDestroy();  // entries

   783     if(!count)

   784         {

   785         // Mesages are complete.

   786         return KErrNone;

   787         }

   788     if(clientContext->EntryId() != clientContext->OwningService())

   789         {

   790         // Client context must be service for FetchL().

   791         BaseMtm().SwitchCurrentEntryL(clientContext->OwningService());

   792         clientContext = &(BaseMtm().Entry());

   793         }

   794     // Go get the messages.

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

   796     waiter->iStatus = KRequestPending;

   797     CMsvOperation* op = FetchL(waiter->iStatus, aSelection, KFunctionIdFetchSelected);

   798     CleanupStack::PushL(op);

   799     waiter->Start();

   800     CActiveScheduler::Start();

   801     const TInt err = DisplayProgressSummary(op->ProgressL());

   802     CleanupStack::PopAndDestroy(2); // CSI: 47 # op, waiter

   803     IMUM_OUT();

   804     return err;

   805     }

   806 

   807 // ----------------------------------------------------------------------------

   808 // CPop3MtmUi::GetResourceFileName()

   809 // ----------------------------------------------------------------------------

   810 //

   811 void CPop3MtmUi::GetResourceFileName(TFileName& aFileName) const

   812     {

   813     IMUM_CONTEXT( CPop3MtmUi::GetResourceFileName, 0, KImumMtmLog );

   814     IMUM_IN();

   815     

   816     aFileName=KPop3uMtmUiResourceFile;

   817     IMUM_OUT();

   818     }

   819 

   820 // ----------------------------------------------------------------------------

   821 // CPop3MtmUi::GetProgress()

   822 // ----------------------------------------------------------------------------

   823 //

   824 TInt CPop3MtmUi::GetProgress(

   825     const TDesC8& aProgress,

   826     TBuf<EProgressStringMaxLen>& aReturnString,

   827     TInt& aTotalEntryCount,

   828     TInt& aEntriesDone,

   829     TInt& aCurrentEntrySize,

   830     TInt& aCurrentBytesTrans) const

   831     {

   832     IMUM_CONTEXT( CPop3MtmUi::GetProgress, 0, KImumMtmLog );

   833     IMUM_IN();

   834     

   835     aReturnString.Zero();

   836     aTotalEntryCount=0;

   837     aEntriesDone=0;

   838     aCurrentEntrySize=0;

   839     aCurrentBytesTrans=0;

   840     if( (!aProgress.Length()) ||

   841         (aProgress.Size() == sizeof(TMsvLocalOperationProgress)) )

   842         {

   843         IMUM_OUT();

   844         return KErrNone;

   845         }

   846     const TInt progressType = ProgressType(aProgress);

   847     if(progressType <= TPop3Progress::EPopMaxProgressValue)

   848         {

   849         IMUM_OUT();

   850         return GetEngineProgress(

   851             aProgress,

   852             aReturnString,

   853             aTotalEntryCount,

   854             aEntriesDone,

   855             aCurrentEntrySize,

   856             aCurrentBytesTrans);

   857         }

   858     else

   859         {

   860         IMUM_OUT();

   861         return GetUiProgress(

   862             aProgress,

   863             aReturnString,

   864             aTotalEntryCount,

   865             aEntriesDone,

   866             aCurrentEntrySize,

   867             aCurrentBytesTrans);

   868         }

   869     }

   870 

   871 // ----------------------------------------------------------------------------

   872 // CPop3MtmUi::ProgressType()

   873 // Find the type of the progress. Progress type is identified by the first

   874 // TInt in the buffer.

   875 // ----------------------------------------------------------------------------

   876 //

   877 TInt CPop3MtmUi::ProgressType(const TDesC8& aProgress) const

   878     {

   879     IMUM_CONTEXT( CPop3MtmUi::ProgressType, 0, KImumMtmLog );

   880     IMUM_IN();

   881     

   882     TPckgC<TInt> type(0);

   883     type.Set(aProgress.Left(sizeof(TInt)));

   884     const TInt progressType = type();

   885     __ASSERT_DEBUG(

   886         progressType==TPop3Progress::EPopRefreshing

   887         || progressType==TPop3Progress::EPopCopying

   888         || progressType==TPop3Progress::EPopDeleting

   889         || progressType==TPop3Progress::EPopConnecting

   890         || progressType==TPop3Progress::EPopTidying

   891         || progressType==TPop3Progress::EPopConnectedAndIdle

   892         || progressType==TPop3Progress::EPopDisconnecting

   893         || progressType==TPop3Progress::EPopDisconnected

   894         || progressType==TPop3Progress::EPopMoving

   895         || progressType==TPop3Progress::EPopCopyNewMail

   896         || progressType==TPop3Progress::EPopMoveNewMail

   897         || progressType==TPop3Progress::EPopCopyMailSelection

   898         || progressType==TPop3Progress::EPopMoveMailSelection

   899         || progressType==TPop3Progress::EPopCopyAllMail

   900         || progressType==TPop3Progress::EPopMoveAllMail

   901         || progressType==TPop3Progress::EPopPopulating

   902         || progressType==TPop3Progress::EPopCancellingOfflineOps

   903         || progressType==EUiProgTypeEditing

   904         || progressType==EUiProgTypeConnecting

   905         || progressType==TPop3Progress::EPopTopPopulating,

   906         User::Panic(KImumMtmUiPanic, EPop3MtmUiUnknownOperation));

   907     IMUM_OUT();

   908     return progressType;

   909     }

   910 

   911 // ----------------------------------------------------------------------------

   912 // CPop3MtmUi::GetEngineProgress()

   913 // ----------------------------------------------------------------------------

   914 //

   915 TInt CPop3MtmUi::GetEngineProgress(

   916     const TDesC8& aProgress,

   917     TBuf<EProgressStringMaxLen>& aReturnString,

   918     TInt& aTotalEntryCount,

   919     TInt& aEntriesDone,

   920     TInt& aCurrentEntrySize,

   921     TInt& aCurrentBytesTrans) const

   922     {

   923     IMUM_CONTEXT( CPop3MtmUi::GetEngineProgress, 0, KImumMtmLog );

   924     IMUM_IN();

   925     

   926     // Unpack the progress buffer in the appropriate POP3 progress object

   927     __ASSERT_ALWAYS(aProgress.Size() == sizeof(TPop3Progress), User::Panic(KImumMtmUiPanic, EPop3MtmUiNoProgress));

   928     TPckgBuf<TPop3Progress> paramPack;

   929     paramPack.Copy(aProgress);

   930     const TPop3Progress& progress = paramPack();

   931     // Extract the information on the entries which have been done

   932     aTotalEntryCount = progress.iTotalMsgs;

   933     aEntriesDone = Min(aTotalEntryCount, aTotalEntryCount - progress.iMsgsToProcess);

   934     aCurrentEntrySize = progress.iTotalBytes;

   935     aCurrentBytesTrans = progress.iBytesDone;

   936 

   937     // Get the progress description

   938     TInt resourceId = 0;

   939     switch(progress.iPop3Progress)

   940         {

   941     case TPop3Progress::EPopConnectedAndIdle:

   942     case TPop3Progress::EPopConnecting:

   943     case TPop3Progress::EPopDisconnecting:

   944     case TPop3Progress::EPopDisconnected:

   945         aCurrentEntrySize = 0;

   946         aCurrentBytesTrans = 0;

   947         IMUM_OUT();

   948         return progress.iErrorCode;     // No progress text for these states.

   949 

   950     case TPop3Progress::EPopTidying:

   951     case TPop3Progress::EPopRefreshing:

   952         if(progress.iTotalMsgs == 0)

   953             {

   954             // Display 'Connecting to <SERVER NAME>', rather than 'Getting header 0 of 0'

   955             TRAPD(err, FormatConnectingServerProgressTextL(

   956                 progress.iServiceId, aReturnString));

   957             if(err == KErrNone)

   958                 {

   959                 err = progress.iErrorCode;

   960                 }

   961             aCurrentEntrySize = 0;

   962             aCurrentBytesTrans = 0;

   963             IMUM_OUT();

   964             return err;

   965             }

   966         resourceId = R_POP3_UPDATING_INBOX;

   967         break;

   968 

   969     case TPop3Progress::EPopMoveNewMail:

   970     case TPop3Progress::EPopMoveAllMail:

   971     case TPop3Progress::EPopMoveMailSelection:

   972     case TPop3Progress::EPopMoving:

   973         __ASSERT_DEBUG( EFalse, User::Panic(KImumMtmUiPanic,   EPop3MtmUiMoveNotAllowed ));

   974         break;

   975     case TPop3Progress::EPopCopyNewMail:

   976     case TPop3Progress::EPopCopyAllMail:

   977     case TPop3Progress::EPopCopyMailSelection:

   978     case TPop3Progress::EPopCopying:

   979         resourceId = (progress.iTotalMsgs == 1) ?

   980             (R_POP3_COPYING_IMAIL_PROGRESS) : (R_POP3_COPYING_MULTI_IMAIL_PROGRESS);

   981         break;

   982     case TPop3Progress::EPopDeleting:

   983         resourceId = (progress.iTotalMsgs == 1) ?

   984             (R_POP3_DELETING_IMAIL_PROGRESS) : (R_POP3_DELETING_IMAIL_PROGRESS_MANY);

   985         break;

   986     case TPop3Progress::EPopPopulating:

   987     case TPop3Progress::EPopTopPopulating:

   988         resourceId = (progress.iTotalMsgs == 1) ?

   989             (R_POP3_POPULATING_SINGLE) : (R_POP3_POPULATING_MULTIPLE);

   990 		//We don't want progressbar, but wait animation instead. This is achieved 

   991 		//by denying progress information.

   992         aTotalEntryCount = 0;

   993 	    aEntriesDone = 0;

   994 	    aCurrentEntrySize = 0;

   995 	    aCurrentBytesTrans = 0;

   996         break;

   997     case TPop3Progress::EPopCancellingOfflineOps:

   998         resourceId = (progress.iTotalMsgs == 1) ?

   999             (R_POP3_UNDELETING_IMAIL_PROGRESS) : (R_POP3_UNDELETING_MULTI_IMAIL_PROGRESS);

  1000         break;

  1001     default:

  1002         User::Panic(KImumMtmUiPanic, EPop3MtmUiUnknownOperation);

  1003         break;

  1004         };

  1005     //

  1006     // Format the return progress string as appropriate

  1007     if (resourceId!=0)

  1008         {

  1009         StringLoader::Load( aReturnString, resourceId, iCoeEnv);

  1010         if ( resourceId != R_POP3_UPDATING_INBOX &&

  1011              progress.iTotalMsgs>1 )

  1012             {

  1013             TBuf<EProgressStringMaxLen> tempBuffer;

  1014             StringLoader::Format(

  1015                 tempBuffer,

  1016                 aReturnString,

  1017                 KImumEntriesDoneReplaceIndex,

  1018                 Min(progress.iTotalMsgs, progress.iTotalMsgs - progress.iMsgsToProcess+1) );

  1019             StringLoader::Format(

  1020                 aReturnString,

  1021                 tempBuffer,

  1022                 KImumTotalEntriesReplaceIndex,

  1023                 progress.iTotalMsgs );

  1024             }

  1025         }

  1026     else

  1027         {

  1028         aReturnString.Zero();

  1029         }

  1030     IMUM_OUT();

  1031 

  1032     return progress.iErrorCode;

  1033     }

  1034 

  1035 // ----------------------------------------------------------------------------

  1036 // CPop3MtmUi::GetUiProgress()

  1037 // ----------------------------------------------------------------------------

  1038 //

  1039 TInt CPop3MtmUi::GetUiProgress(

  1040     const TDesC8& aProgress,

  1041     TBuf<EProgressStringMaxLen>& aReturnString,

  1042     TInt& aTotalEntryCount,

  1043     TInt& aEntriesDone,

  1044     TInt& aCurrentEntrySize,

  1045     TInt& aCurrentBytesTrans) const

  1046     {

  1047     IMUM_CONTEXT( CPop3MtmUi::GetUiProgress, 0, KImumMtmLog );

  1048     IMUM_IN();

  1049     

  1050     switch(ProgressType(aProgress))

  1051         {

  1052         case EUiProgTypeEditing:

  1053             break;

  1054         case EUiProgTypeConnecting:

  1055             IMUM_OUT();

  1056             return GetConnectionProgress(

  1057                 aProgress,

  1058                 aReturnString,

  1059                 aTotalEntryCount,

  1060                 aEntriesDone,

  1061                 aCurrentEntrySize,

  1062                 aCurrentBytesTrans);

  1063 

  1064         default:

  1065             User::Panic(KImumMtmUiPanic, EPop3MtmUiUnknownOperation);

  1066             break;

  1067         }

  1068     IMUM_OUT();

  1069     return KErrNone;

  1070     }

  1071 

  1072 // ----------------------------------------------------------------------------

  1073 // CPop3MtmUi::GetConnectionProgress()

  1074 // ----------------------------------------------------------------------------

  1075 //

  1076 TInt CPop3MtmUi::GetConnectionProgress(

  1077     const TDesC8& aProgress,

  1078     TBuf<EProgressStringMaxLen>& aReturnString,

  1079     TInt& /*aTotalEntryCount*/,

  1080     TInt& /*aEntriesDone*/,

  1081     TInt& /*aCurrentEntrySize*/,

  1082     TInt& /*aCurrentBytesTrans*/) const

  1083     {

  1084     IMUM_CONTEXT( CPop3MtmUi::GetConnectionProgress, 0, KImumMtmLog );

  1085     IMUM_IN();

  1086     

  1087     // Unpack the progress buffer in the appropriate progress object

  1088     __ASSERT_ALWAYS(aProgress.Size() == sizeof(TMsvEmailConnectionProgress), User::Panic(KImumMtmUiPanic, EPop3MtmUiNoProgress));

  1089     TPckgBuf<TMsvEmailConnectionProgress> paramPack;

  1090     paramPack.Copy(aProgress);

  1091     const TMsvEmailConnectionProgress& progress = paramPack();

  1092 

  1093     // Get the progress text.

  1094     switch(progress.iState)

  1095         {

  1096         case TMsvEmailConnectionProgress::EInitialising:

  1097         case TMsvEmailConnectionProgress::EConnectNetwork:

  1098         case TMsvEmailConnectionProgress::EConnectMailbox:

  1099             MsvEmailMtmUiUtils::CreateConnectingToText( aReturnString,

  1100                 Session(), BaseMtm().Entry().EntryId() );

  1101             break;

  1102         default:

  1103             User::Panic(KImumMtmUiPanic, EPop3MtmUiUnknownProgressState);

  1104             break;

  1105         }

  1106     IMUM_OUT();

  1107     return KErrNone;

  1108     }

  1109 

  1110 // ----------------------------------------------------------------------------

  1111 // CPop3MtmUi::GetDeleteProgress()

  1112 // ----------------------------------------------------------------------------

  1113 //

  1114 TInt CPop3MtmUi::GetDeleteProgress(TInt aTotalMsgs, TInt aError, TBuf<EProgressStringMaxLen>& aReturnString, TInt& aTotalEntryCount, TInt& aEntriesDone,

  1115     TInt& aCurrentEntrySize, TInt& aCurrentBytesTrans) const

  1116     {

  1117     IMUM_CONTEXT( CPop3MtmUi::GetDeleteProgress, 0, KImumMtmLog );

  1118     IMUM_IN();

  1119     

  1120     // Delete progress is something of a special case since it reports only the total

  1121     // number of messages to be deleted, and has no progress bar.

  1122     aEntriesDone = 0;

  1123     aTotalEntryCount = 0;

  1124     aCurrentEntrySize = 0;

  1125     aCurrentBytesTrans = 0;

  1126     if(aTotalMsgs >= 2)

  1127         {

  1128         TBuf<EProgressStringMaxLen> resource;

  1129         TRAP_IGNORE( iCoeEnv->ReadResourceL( resource, 

  1130             R_POP3_DELETING_IMAIL_PROGRESS_MANY ) );

  1131         aReturnString.Format(resource, aTotalMsgs);

  1132         }

  1133     else

  1134         {