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:  ImumInMailboxUtilitiesImpl.cpp

    15 *

    16 */

    17 

    18 

    19 #include <e32base.h>

    20 #include <SendUiConsts.h>

    21 #include <msvapi.h>                         // CMsvSession

    22 #include <msvstd.hrh>                       // Constants

    23 #include <mtudreg.h>                        // CMtmUiDataRegistry

    24 #include <cemailaccounts.h>                 // CEmailAccounts

    25 #include <iapprefs.h>                       // CImIAPPreferences

    26 

    27 #include "ImumInMailboxUtilitiesImpl.h"

    28 #include "ImumInMailboxServicesImpl.h"

    29 #include "ImumInternalApiImpl.h"

    30 #include "ImumMboxManager.h"                // CImumMboxManager

    31 #include "ImumMboxScheduler.h"              // CImumMboxSchdeuler

    32 #include "ImumUtilsLogging.h"

    33 #include "muiuemailtools.h"

    34 #include "ComDbUtl.h"

    35 

    36 // CONSTANTS

    37 _LIT( KImumInImapInboxName,"INBOX");

    38 

    39 // ================ CLASS CONSTRUCTION ================

    40 

    41 // ---------------------------------------------------------------------------

    42 // CImumInMailboxUtilitiesImpl::CImumInMailboxUtilitiesImpl()

    43 // ---------------------------------------------------------------------------

    44 //

    45 CImumInMailboxUtilitiesImpl::CImumInMailboxUtilitiesImpl(

    46     CImumInternalApiImpl& aMailboxApi )

    47     :

    48     iMailboxApi( aMailboxApi )

    49     {

    50     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::CImumInMailboxUtilitiesImpl, 0, KLogInApi );

    51     IMUM_IN();

    52     IMUM_OUT();

    53     }

    54 

    55 // ---------------------------------------------------------------------------

    56 // CImumInMailboxUtilitiesImpl::~CImumInMailboxUtilitiesImpl()

    57 // ---------------------------------------------------------------------------

    58 //

    59 CImumInMailboxUtilitiesImpl::~CImumInMailboxUtilitiesImpl()

    60     {

    61     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::~CImumInMailboxUtilitiesImpl, 0, KLogInApi );

    62     IMUM_IN();

    63 

    64     delete iMtmUiDataRegistry;

    65     iMtmUiDataRegistry = NULL;

    66 

    67     IMUM_OUT();

    68     }

    69 

    70 // ---------------------------------------------------------------------------

    71 // CImumInMailboxUtilitiesImpl::NewL()

    72 // ---------------------------------------------------------------------------

    73 //

    74 CImumInMailboxUtilitiesImpl* CImumInMailboxUtilitiesImpl::NewL(

    75     CImumInternalApiImpl& aMailboxApi )

    76     {

    77     IMUM_STATIC_CONTEXT( CImumInMailboxUtilitiesImpl::NewL, 0, utils, KLogInApi );

    78     IMUM_IN();

    79 

    80     CImumInMailboxUtilitiesImpl* self = NewLC( aMailboxApi );

    81     CleanupStack::Pop( self );

    82 

    83     IMUM_OUT();

    84 

    85     return self;

    86     }

    87 

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

    89 // CImumInMailboxUtilitiesImpl::NewLC()

    90 // ---------------------------------------------------------------------------

    91 //

    92 CImumInMailboxUtilitiesImpl* CImumInMailboxUtilitiesImpl::NewLC(

    93     CImumInternalApiImpl& aMailboxApi )

    94     {

    95     IMUM_STATIC_CONTEXT( CImumInMailboxUtilitiesImpl::NewLC, 0, utils, KLogInApi );

    96     IMUM_IN();

    97 

    98     CImumInMailboxUtilitiesImpl* self =

    99         new ( ELeave ) CImumInMailboxUtilitiesImpl( aMailboxApi );

   100     CleanupStack::PushL( self );

   101 

   102     self->ConstructL();

   103 

   104     IMUM_OUT();

   105 

   106     return self;

   107     }

   108 

   109 // ---------------------------------------------------------------------------

   110 // CImumInMailboxUtilitiesImpl::ConstructL()

   111 // ---------------------------------------------------------------------------

   112 //

   113 void CImumInMailboxUtilitiesImpl::ConstructL()

   114     {

   115     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::ConstructL, 0, KLogInApi );

   116     IMUM_IN();

   117 

   118     iMtmUiDataRegistry = CMtmUiDataRegistry::NewL( iMailboxApi.MsvSession() );

   119 

   120     IMUM_OUT();

   121     }

   122 

   123 // ================ INTERFACE IMPLEMENTATION ================

   124 

   125 // ---------------------------------------------------------------------------

   126 // From class MImumInMailboxUtilities.

   127 // CImumInMailboxUtilitiesImpl::DefaultMailbox()

   128 // ---------------------------------------------------------------------------

   129 //

   130 TMsvId CImumInMailboxUtilitiesImpl::DefaultMailboxId(

   131     const TBool aForceGet ) const

   132     {

   133     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::DefaultMailboxId, 0, KLogInApi );

   134     IMUM_IN();

   135 

   136     TMsvId defaultId = KMsvUnknownServiceIndexEntryId;

   137 

   138     //Should not leave, defaultId is just unknown

   139     TRAP_IGNORE( defaultId = DefaultMailboxIdL( aForceGet ) );

   140 

   141     IMUM1(0,"Default mailbox: 0x%x", defaultId );

   142     IMUM_OUT();

   143 

   144     return defaultId;

   145     }

   146 

   147 // ---------------------------------------------------------------------------

   148 // From class MImumInMailboxUtilities.

   149 // CImumInMailboxUtilitiesImpl::IsMailMtm()

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

   151 //

   152 TBool CImumInMailboxUtilitiesImpl::IsMailMtm(

   153     const TUid& aMtm,

   154     const TBool& aAllowExtended ) const

   155     {

   156     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::IsMailMtm, 0, KLogInApi );

   157     IMUM_IN();

   158 

   159     // Basic mail mtm's

   160     TBool basicMtms =

   161         ( aMtm == KSenduiMtmSmtpUid ) ||

   162         ( aMtm == KSenduiMtmPop3Uid ) ||

   163         ( aMtm == KSenduiMtmImap4Uid );

   164 

   165     // Extended mail mtm's

   166     // Check if mailbox is 3rd party mailbox.

   167     TBool extendedMtms = EFalse;

   168     

   169     if( aAllowExtended && !basicMtms )

   170     	{

   171         // We donīt know 3rd party mailbox uid values so technology type

   172         // is compared instead.

   173     	if( iMtmUiDataRegistry->IsPresent( aMtm ) )

   174     	    {

   175             const TUid& technologyType =

   176                 iMtmUiDataRegistry->TechnologyTypeUid( aMtm );

   177             extendedMtms = ( KSenduiTechnologyMailUid == technologyType );

   178     	    }

   179     	}

   180 

   181     IMUM_OUT();

   182 

   183     // Returns ETrue, if the id is any of the following

   184     return basicMtms || ( aAllowExtended && extendedMtms );

   185     }

   186 

   187 // ---------------------------------------------------------------------------

   188 // From class MImumInMailboxUtilities.

   189 // CImumInMailboxUtilitiesImpl::IsMailbox()

   190 // ---------------------------------------------------------------------------

   191 //

   192 TBool CImumInMailboxUtilitiesImpl::IsMailbox( const TMsvId aMailboxId ) const

   193     {

   194     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::IsMailbox, 0, KLogInApi );

   195     IMUM_IN();

   196 

   197     // First get the entry and make sure it is a service

   198     TBool isMailbox = EFalse;

   199     TMsvId serviceId;

   200     TMsvEntry entry;

   201     if ( !iMailboxApi.MsvSession().GetEntry( aMailboxId, serviceId, entry ) &&

   202           entry.iType.iUid == KUidMsvServiceEntryValue )

   203         {

   204         // Get the technology type of the entry

   205         const TUid& technologyType =

   206             iMtmUiDataRegistry->TechnologyTypeUid( entry.iMtm );

   207 

   208         // Match with mail technology type

   209         isMailbox = ( KSenduiTechnologyMailUid == technologyType );

   210         }

   211 

   212     IMUM_OUT();

   213 

   214     return isMailbox;

   215     }

   216 

   217 // ---------------------------------------------------------------------------

   218 // From class MImumInMailboxUtilities.

   219 // CImumInMailboxUtilitiesImpl::IsMailbox()

   220 // ---------------------------------------------------------------------------

   221 //

   222 TBool CImumInMailboxUtilitiesImpl::IsMailbox(

   223     const TMsvEntry& aEntry ) const

   224     {

   225     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::IsMailbox, 0, KLogInApi );

   226     IMUM_IN();

   227 

   228     // At first, make sure the entry is a service

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

   230         {

   231         // Get the technology type of the entry

   232         const TUid& technologyType =

   233             iMtmUiDataRegistry->TechnologyTypeUid( aEntry.iMtm );

   234 

   235         // Match with mail technology type

   236         return ( KSenduiTechnologyMailUid == technologyType );

   237         }

   238 

   239     IMUM_OUT();

   240 

   241     return EFalse;

   242     }

   243 

   244 // ---------------------------------------------------------------------------

   245 // From class MImumInMailboxUtilities.

   246 // CImumInMailboxUtilitiesImpl::GetMailboxL()

   247 // ---------------------------------------------------------------------------

   248 //

   249 TMsvEntry CImumInMailboxUtilitiesImpl::GetMailboxEntryL(

   250     const TMsvId aMailboxId,

   251     const TImumInMboxRequest& aType,

   252     const TBool aServiceCheck ) const

   253     {

   254     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::GetMailboxEntryL, 0, KLogInApi );

   255     IMUM_IN();

   256 

   257     // Get the entry based on mailbox id

   258     TMsvId serviceId;

   259     TMsvEntry entry;

   260     User::LeaveIfError( iMailboxApi.MsvSession().GetEntry(

   261         aMailboxId, serviceId, entry ) );

   262 

   263     // Make sure the id is mailbox

   264     if ( !( aServiceCheck && !IsMailbox( entry ) ) )

   265         {

   266         // Continue handling, if successful

   267         if ( aType != ERequestCurrent )

   268             {

   269             TInt32 mtm = entry.iMtm.iUid;

   270 

   271             // Get related entry, if:

   272             // Mailbox type is smtp and pop3 or imap4 is wanted OR

   273             // Mailbox type is pop3 or imap4 and smtp is wanted

   274             if ( aType == ERequestSending && mtm != KSenduiMtmSmtpUidValue ||

   275                  aType == ERequestReceiving && mtm == KSenduiMtmSmtpUidValue )

   276                 {

   277                 User::LeaveIfError( iMailboxApi.MsvSession().GetEntry(

   278                     entry.iRelatedId, serviceId, entry ) );

   279                 }

   280             }

   281         }

   282     else

   283         {

   284         User::Leave( KErrUnknown );

   285         }

   286 

   287     IMUM_OUT();

   288 

   289     return entry;

   290     }

   291 

   292 // ---------------------------------------------------------------------------

   293 // From class MImumInMailboxUtilities.

   294 // CImumInMailboxUtilitiesImpl::GetMailboxEntriesL()

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

   296 //

   297 const TUid& CImumInMailboxUtilitiesImpl::GetMailboxEntriesL(

   298     const TMsvId aMailboxId,

   299     RMsvEntryArray& aEntries,

   300     const TBool aResetArray ) const

   301     {

   302     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::GetMailboxEntriesL, 0, KLogInApi );

   303     IMUM_IN();

   304 

   305     // Reset the array on request

   306     if ( aResetArray )

   307         {

   308         aEntries.Reset();

   309         }

   310 

   311     // Get the entries

   312     aEntries.Append( GetMailboxEntryL( aMailboxId, ERequestReceiving ) );

   313     aEntries.Append( GetMailboxEntryL( aMailboxId, ERequestSending ) );

   314 

   315     IMUM_OUT();

   316 

   317     // return the mtm id

   318     return aEntries[0].iMtm;

   319     }

   320 

   321 // ---------------------------------------------------------------------------

   322 // From class MImumInMailboxUtilities.

   323 // CImumInMailboxUtilitiesImpl::IsInbox()

   324 // ---------------------------------------------------------------------------

   325 //

   326 TBool CImumInMailboxUtilitiesImpl::IsInbox(

   327     const TMsvEntry& aFolderEntry ) const

   328     {

   329     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::IsInbox, 0, KLogInApi );

   330     IMUM_IN();

   331 

   332     TBool isInbox( EFalse );

   333     if ( aFolderEntry.iDetails.CompareF( KImumInImapInboxName ) == 0 )

   334         {

   335         // If parent is Mailbox service, then this is IMAP4 protocol inbox,

   336         // otherwise it is something else...

   337         TMsvId serviceId;

   338         TMsvEntry entry;

   339         TInt error = iMailboxApi.MsvSession().GetEntry(

   340             aFolderEntry.Parent(), serviceId, entry );

   341         if ( ( error == KErrNone ) && ( entry.Id() == serviceId ) )

   342             {

   343             isInbox = ETrue;

   344             }

   345         }

   346 

   347     IMUM_OUT();

   348 

   349     return isInbox;

   350     }

   351 

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

   353 // From class MImumInMailboxUtilities.

   354 // CImumInMailboxUtilitiesImpl::HasWlanConnectionL()

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

   356 //

   357 TBool CImumInMailboxUtilitiesImpl::HasWlanConnectionL(

   358     const TMsvId aMailboxId ) const

   359     {

   360     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::HasWlanConnectionL, 0, KLogInApi );

   361     IMUM_IN();

   362 

   363     // Connecting to WLAN accesspoint is allowed to offline mode also,

   364     // so return ETrue if WLAN access point

   365     TBool wlanIap = EFalse;

   366 

   367     CEmailAccounts* account = CEmailAccounts::NewLC();

   368     CImIAPPreferences* iapPreferences = CImIAPPreferences::NewLC();

   369 

   370     TMsvId serviceId;

   371     TMsvEntry mailbox;

   372     TInt error = iMailboxApi.MsvSession().GetEntry( aMailboxId,

   373     												serviceId,

   374     												mailbox );

   375 

   376     // In some cases the mailId is passed to this method instead of the actual mailboxId so we

   377     // need to check the owningService as well.

   378     CMsvEntry* owningEntry = iMailboxApi.MsvSession().GetEntryL(aMailboxId);

   379     CleanupStack::PushL( owningEntry );

   380     TMsvId owningService = owningEntry->OwningService();

   381     CleanupStack::PopAndDestroy( owningEntry );

   382 

   383     // Make sure that the entry belongs to mailbox

   384     if ( !IsMailbox( mailbox ) )

   385     	{

   386     	if ( !IsMailbox( owningService ) )

   387         	{

   388         	IMUM0(0, "Not a mailbox");

   389         	error = KErrNotSupported;

   390         	}

   391         }

   392 

   393     if ( error == KErrNone )

   394         {

   395         IMUM0(0, "Retrieving preferences");

   396         error = CImumMboxManager::GetIapPreferencesL(

   397             serviceId,

   398             *account,

   399             *iapPreferences,

   400             iMailboxApi,

   401             ( mailbox.iMtm == KSenduiMtmSmtpUid ) );

   402         }

   403 

   404     if ( error == KErrNone && iapPreferences->NumberOfIAPs() )

   405         {

   406         IMUM0(0, "Accesspoints exist");

   407         TImIAPChoice iap = iapPreferences->IAPPreference( 0 );

   408 

   409         // Do not allow always ask

   410         if ( iap.iIAP > 0 )

   411             {

   412             CMsvCommDbUtilities* dbUtils = CMsvCommDbUtilities::NewLC();

   413 

   414             TRAPD( error, wlanIap = dbUtils->IsWlanAccessPointL( iap.iIAP ) );

   415             // If access point item is not found, force always ask

   416             if ( error )

   417                 {

   418                 CImumMboxManager::ForceAlwaysAskL(

   419                     serviceId,

   420                     *account,

   421                     *iapPreferences,

   422                     iMailboxApi,

   423                     EFalse );

   424                 wlanIap = ETrue;

   425                 }

   426             CleanupStack::PopAndDestroy(); // dbUtils

   427             }

   428         else

   429             {

   430             // Return ETrue for the always ask

   431             wlanIap = ETrue;

   432             }

   433         }

   434     CleanupStack::PopAndDestroy( 2, account ); // CSI: 47 # iapPreferences, account.

   435 

   436     IMUM_OUT();

   437     return wlanIap;

   438     }

   439 

   440 // ----------------------------------------------------------------------------

   441 // From class MImumInMailboxUtilities.

   442 // CImumInMailboxUtilitiesImpl::HasSubscribedFoldersL()

   443 // ----------------------------------------------------------------------------

   444 //

   445 TBool CImumInMailboxUtilitiesImpl::HasSubscribedFoldersL(

   446     const TMsvId aFolderId ) const

   447     {

   448     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::HasSubscribedFoldersL, 0, KLogInApi );

   449     IMUM_IN();

   450 

   451     // Make sure the id is receiving

   452     TMsvEntry rcv = iMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

   453         aFolderId,

   454         MImumInMailboxUtilities::ERequestReceiving,

   455         EFalse );

   456 

   457     // Get the folder entry

   458     CMsvEntry* folderEntry = iMailboxApi.MsvSession().GetEntryL( rcv.Id() );

   459     CleanupStack::PushL( folderEntry );

   460 

   461     // Subscribed folders are hidden entries before the first sync

   462     TMsvSelectionOrdering order = folderEntry->SortType();

   463     order.SetShowInvisibleEntries( ETrue );

   464     folderEntry->SetSortTypeL( order );

   465 

   466     TBool found( EFalse );

   467 

   468     // Search through all the folders and locate the subscribed ones

   469     const TInt count = folderEntry->Count();

   470     for ( TInt loop = 0; !found && loop < count; loop++ )

   471         {

   472         TMsvEmailEntry mailEntry = ( *folderEntry )[ loop ];

   473         if ( mailEntry.iType.iUid == KUidMsvFolderEntryValue )

   474             {

   475             if ( mailEntry.LocalSubscription() && !IsInbox( mailEntry ) )

   476                 {

   477                 found = ETrue;

   478                 }

   479             else

   480                 {

   481                 // Go into the folder to search the new entry

   482                 found = HasSubscribedFoldersL( mailEntry.Id() );

   483                 }

   484             }

   485         }

   486 

   487     CleanupStack::PopAndDestroy( folderEntry );

   488 

   489     IMUM_OUT();

   490 

   491     return found;

   492     }

   493 

   494 // ---------------------------------------------------------------------------

   495 // From class MImumInMailboxUtilities.

   496 // CImumInMailboxUtilitiesImpl::IsAlwaysOnlineOnL()

   497 // ---------------------------------------------------------------------------

   498 //

   499 void CImumInMailboxUtilitiesImpl::QueryAlwaysOnlineStateL(

   500     const TMsvId aMailboxId,

   501     TInt64& aAlwaysOnlineStatus ) const

   502     {

   503     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::QueryAlwaysOnlineStateL, 0, KLogInApi );

   504     IMUM_IN();

   505 

   506     // Query the result from the scheduler utility

   507     CImumMboxScheduler* scheduler = CImumMboxScheduler::NewLC(

   508         iMailboxApi, aMailboxId );

   509     aAlwaysOnlineStatus = scheduler->QueryAlwaysOnlineStateL();

   510 

   511     // Cleanup

   512     CleanupStack::PopAndDestroy( scheduler );

   513     scheduler = NULL;

   514 

   515     IMUM_OUT();

   516     }

   517 

   518 // ---------------------------------------------------------------------------

   519 // From class MImumInMailboxUtilities.

   520 // CImumInMailboxUtilitiesImpl::NextAlwaysOnlineIntervalL()

   521 // ---------------------------------------------------------------------------

   522 //

   523 void CImumInMailboxUtilitiesImpl::NextAlwaysOnlineIntervalL(

   524     const TMsvId aMailboxId,

   525     TInt64& aAlwaysOnlineStatus,

   526     TTimeIntervalSeconds& aSeconds ) const

   527     {

   528     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::NextAlwaysOnlineIntervalL, 0, KLogInApi );

   529     IMUM_IN();

   530 

   531     // Query the result from the scheduler utility

   532     CImumMboxScheduler* scheduler = CImumMboxScheduler::NewLC(

   533         iMailboxApi, aMailboxId );

   534     aAlwaysOnlineStatus = scheduler->SecondsToNextMark( aSeconds );

   535 

   536     // Cleanup

   537     CleanupStack::PopAndDestroy( scheduler );

   538     scheduler = NULL;

   539 

   540     IMUM_OUT();

   541     }

   542 

   543 // ---------------------------------------------------------------------------

   544 // From class MImumInMailboxUtilities.

   545 // CImumInMailboxUtilitiesImpl::DefaultMailboxIdL()

   546 // ---------------------------------------------------------------------------

   547 //

   548 TMsvId CImumInMailboxUtilitiesImpl::DefaultMailboxIdL(

   549     const TBool aForceGet ) const

   550     {

   551     IMUM_CONTEXT( CImumInMailboxUtilitiesImpl::DefaultMailboxIdL, 0, KLogInApi );

   552     IMUM_IN();

   553 

   554     // The system must have default mtm for mailboxes, so find one

   555     TUid defaultMtm = KSenduiMtmSmtpUid;

   556 

   557     TMsvId defaultId = MuiuEmailTools::DefaultSendingMailboxL(

   558         iMailboxApi.MsvSession(), defaultMtm );

   559 

   560     // There's no such of thing, so force find any.

   561     // This may be true in case the message store has been swapped between

   562     // the phone and memorycard. Forcing default mailbox makes it possible

   563     // to write and send emails without problems.

   564     if ( aForceGet && defaultId == KMsvUnknownServiceIndexEntryId )

   565         {

   566         // Find first valid mailbox

   567         iMailboxApi.MailboxServicesL().SetDefaultMailboxL( 0 );

   568         defaultId = MuiuEmailTools::DefaultSendingMailboxL(

   569             iMailboxApi.MsvSession(), defaultMtm );

   570         }

   571 

   572     IMUM_OUT();

   573     return defaultId;

   574     }

   575