meetingrequest/mrentry/src/cesmrfsmailboxutils.cpp
branchRCL_3
changeset 35 e64954c2c8e2
parent 33 da5135c61bad
equal deleted inserted replaced
34:cd2816114bd1 35:e64954c2c8e2
    14 * Description:  ESMR FS mailbox utilities implementation
    14 * Description:  ESMR FS mailbox utilities implementation
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 
    18 
    19 #include "emailtrace.h"
       
    20 #include "cesmrfsmailboxutils.h"
    19 #include "cesmrfsmailboxutils.h"
       
    20 
    21 #include "esmrhelper.h"
    21 #include "esmrhelper.h"
    22 #include "esmrinternaluid.h"
    22 #include "esmrinternaluid.h"
    23 
    23 
       
    24 #include "cfsmailclient.h"
       
    25 #include "cfsmailbox.h"
       
    26 #include "cmrcalendarinfo.h"
       
    27 
    24 #include <calentry.h>
    28 #include <calentry.h>
    25 //<cmail>
       
    26 #include "CFSMailClient.h"
       
    27 #include "CFSMailBox.h"
       
    28 //</cmail>
       
    29 #include <caluser.h>
    29 #include <caluser.h>
    30 #include <ct/rcpointerarray.h>
    30 #include <ct/rcpointerarray.h>
       
    31 
       
    32 #include "emailtrace.h"
    31 
    33 
    32 // Unnamed namespace for local definitions
    34 // Unnamed namespace for local definitions
    33 namespace {
    35 namespace {
    34 
    36 
    35 // Definition for email address comparison
    37 // Definition for email address comparison
    47     TFSMailMsgId msgId;
    49     TFSMailMsgId msgId;
    48     aMailClient.ListMailBoxes(
    50     aMailClient.ListMailBoxes(
    49             msgId,
    51             msgId,
    50             aMailboxes );
    52             aMailboxes );
    51     }
    53     }
       
    54 
       
    55 /**
       
    56  * Helper class for Email extension cleanup
       
    57  */
       
    58 class TExtensionCleanup
       
    59     {
       
    60     public:
       
    61 
       
    62     TExtensionCleanup(
       
    63             CFSMailBox* aMailbox,
       
    64             CEmailExtension* aExtension )
       
    65         : iMailbox( aMailbox ),
       
    66           iExtension( aExtension )
       
    67         {
       
    68         }
       
    69 
       
    70     void Close()
       
    71         {
       
    72         iMailbox->ReleaseExtension( iExtension );
       
    73         }
       
    74 
       
    75     private:
       
    76         /// Not own: mailbox
       
    77         CFSMailBox* iMailbox;
       
    78         // Not own: mailbox extension
       
    79         CEmailExtension* iExtension;
       
    80     };
       
    81 
       
    82 
    52 }
    83 }
    53 
    84 
    54 // ======== MEMBER FUNCTIONS ========
    85 // ======== MEMBER FUNCTIONS ========
    55 
    86 
    56 // ---------------------------------------------------------------------------
    87 // ---------------------------------------------------------------------------
   132         if ( phoneOwner )
   163         if ( phoneOwner )
   133             {
   164             {
   134             aCalEntry.SetPhoneOwnerL( phoneOwner );
   165             aCalEntry.SetPhoneOwnerL( phoneOwner );
   135             err = KErrNone;
   166             err = KErrNone;
   136             }
   167             }
   137         
   168 
   138         CleanupStack::PopAndDestroy( &mailboxes );
   169         CleanupStack::PopAndDestroy( &mailboxes );
   139         }
   170         }
   140     return err;
   171     return err;
   141     }
   172     }
   142 
   173 
   262 // ----------------------------------------------------------------------------
   293 // ----------------------------------------------------------------------------
   263 // CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL
   294 // CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL
   264 // ----------------------------------------------------------------------------
   295 // ----------------------------------------------------------------------------
   265 //
   296 //
   266 EXPORT_C TBool CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL(
   297 EXPORT_C TBool CESMRFsMailboxUtils::DefaultMailboxSupportCapabilityL(
   267         CESMRFsMailboxUtils::TMRMailboxCapability aCapability ) 
   298         CESMRFsMailboxUtils::TMRMailboxCapability aCapability )
   268     {
   299     {
   269     FUNC_LOG;
   300     FUNC_LOG;
   270     
   301 
   271     TBool retValue( EFalse );    
   302     TBool retValue( EFalse );
   272    
   303 
   273     CFSMailBox* defaultMailbox = DefaultMailboxL();
   304     CFSMailBox* defaultMailbox = DefaultMailboxL();
   274     CleanupStack::PushL( defaultMailbox );
   305     CleanupStack::PushL( defaultMailbox );
   275     ASSERT( defaultMailbox );
   306     ASSERT( defaultMailbox );
   276     
   307 
   277     switch ( aCapability )
   308     switch ( aCapability )
   278         {
   309         {
   279         case CESMRFsMailboxUtils::EMRCapabilityAttachment:
   310         case CESMRFsMailboxUtils::EMRCapabilityAttachment:
   280             {
   311             {
   281             retValue = defaultMailbox->HasCapability( 
   312             retValue = defaultMailbox->HasCapability(
   282                             EFSMboxCapaSupportsAttahmentsInMR );
   313                             EFSMboxCapaSupportsAttahmentsInMR );
   283             }
   314             }
   284             break;
   315             break;
   285         }
   316         }
   286     
   317 
   287     CleanupStack::PopAndDestroy( defaultMailbox );
   318     CleanupStack::PopAndDestroy( defaultMailbox );
   288     
   319 
   289     return retValue;
   320     return retValue;
       
   321     }
       
   322 
       
   323 // ----------------------------------------------------------------------------
       
   324 // CESMRFsMailboxUtils::GetCalendarDatabaseIdL
       
   325 // ----------------------------------------------------------------------------
       
   326 //
       
   327 void CESMRFsMailboxUtils::GetCalendarDatabaseIdL(
       
   328             TESMRMailPlugin aPlugin,
       
   329             TCalFileId& aDbId )
       
   330     {
       
   331     FUNC_LOG;
       
   332 
       
   333     TUid pluginUid( TUid::Null() );
       
   334     aDbId = KNullFileId;
       
   335 
       
   336     switch ( aPlugin )
       
   337         {
       
   338         case EESMRActiveSync:
       
   339             {
       
   340             pluginUid = TUid::Uid( KEasFreestylePlugin );
       
   341             break;
       
   342             }
       
   343         case EESMRIntelliSync:
       
   344             {
       
   345             pluginUid = TUid::Uid( KIntellisync );
       
   346             break;
       
   347             }
       
   348         default:
       
   349             {
       
   350             break;
       
   351             }
       
   352         }
       
   353 
       
   354     if ( pluginUid != TUid::Null() )
       
   355         {
       
   356         RCPointerArray<CFSMailBox> mailboxes;
       
   357         CleanupClosePushL( mailboxes );
       
   358 
       
   359         ListMailBoxesL(
       
   360                 MailClientL(),
       
   361                 mailboxes );
       
   362 
       
   363         for ( TInt i = 0; i < mailboxes.Count(); ++i )
       
   364             {
       
   365             CFSMailBox* mailbox = mailboxes[ i ];
       
   366             if ( mailbox->GetId().PluginId() == pluginUid )
       
   367                 {
       
   368                 // Resolve database id using mailbox extension
       
   369                 CEmailExtension* extension =
       
   370                         mailbox->ExtensionL( KMailboxExtMrCalInfo );
       
   371 
       
   372                 TExtensionCleanup cleanup( mailbox, extension );
       
   373                 CleanupClosePushL( cleanup );
       
   374 
       
   375                 CMRCalendarInfo* calInfo =
       
   376                         static_cast< CMRCalendarInfo* >( extension );
       
   377 
       
   378                 if ( calInfo )
       
   379                     {
       
   380                     calInfo->GetCalendarDatabaseIdL( aDbId );
       
   381                     }
       
   382 
       
   383                 CleanupStack::PopAndDestroy( &cleanup ); // Release extension
       
   384                 break;
       
   385                 }
       
   386             }
       
   387 
       
   388         CleanupStack::PopAndDestroy( &mailboxes );
       
   389         }
   290     }
   390     }
   291 
   391 
   292 // ----------------------------------------------------------------------------
   392 // ----------------------------------------------------------------------------
   293 // CESMRFsMailboxUtils::PhoneOwnerL
   393 // CESMRFsMailboxUtils::PhoneOwnerL
   294 // ----------------------------------------------------------------------------
   394 // ----------------------------------------------------------------------------
   374 // ----------------------------------------------------------------------------
   474 // ----------------------------------------------------------------------------
   375 //
   475 //
   376 CFSMailBox* CESMRFsMailboxUtils::DefaultMailboxL()
   476 CFSMailBox* CESMRFsMailboxUtils::DefaultMailboxL()
   377     {
   477     {
   378     FUNC_LOG;
   478     FUNC_LOG;
   379     
   479 
   380     CFSMailBox* defaultMailbox( NULL );
   480     CFSMailBox* defaultMailbox( NULL );
   381     
   481 
   382     CMRMailboxUtils::TMailboxInfo mailboxInfo;
   482     CMRMailboxUtils::TMailboxInfo mailboxInfo;
   383     TInt err = iMRMailboxUtils.GetDefaultMRMailBoxL( mailboxInfo );
   483     TInt err = iMRMailboxUtils.GetDefaultMRMailBoxL( mailboxInfo );
   384     
   484 
   385     if ( KErrNone == err )
   485     if ( KErrNone == err )
   386         {
   486         {
   387         RCPointerArray<CFSMailBox> mailboxes;
   487         RCPointerArray<CFSMailBox> mailboxes;
   388         CleanupClosePushL( mailboxes );
   488         CleanupClosePushL( mailboxes );
   389         
   489 
   390         ListMailBoxesL( MailClientL(), mailboxes );
   490         ListMailBoxesL( MailClientL(), mailboxes );
   391         
   491 
   392         TInt mailboxCount( mailboxes.Count() );
   492         TInt mailboxCount( mailboxes.Count() );
   393         for (TInt j(0); j < mailboxCount && !defaultMailbox; ++j )
   493         for (TInt j(0); j < mailboxCount && !defaultMailbox; ++j )
   394             {
   494             {
   395             TPtrC mailboxOwnerAddName(
   495             TPtrC mailboxOwnerAddName(
   396                     mailboxes[j]->OwnMailAddress().GetEmailAddress() );
   496                     mailboxes[j]->OwnMailAddress().GetEmailAddress() );
   397     
   497 
   398             if ( KEqualEmailAddress == 
   498             if ( KEqualEmailAddress ==
   399                  mailboxOwnerAddName.CompareF( mailboxInfo.iEmailAddress) )
   499                  mailboxOwnerAddName.CompareF( mailboxInfo.iEmailAddress) )
   400                 {
   500                 {
   401                 // Default mailbox is found
   501                 // Default mailbox is found
   402                 defaultMailbox = mailboxes[j];
   502                 defaultMailbox = mailboxes[j];
   403                 mailboxes.Remove( j );
   503                 mailboxes.Remove( j );
   404                 }
   504                 }
   405             }
   505             }
   406         
   506 
   407         CleanupStack::PopAndDestroy( &mailboxes );
   507         CleanupStack::PopAndDestroy( &mailboxes );
   408         }
   508         }
   409     
   509 
   410     return defaultMailbox;
   510     return defaultMailbox;
   411     }
   511     }
   412 
   512 
   413 // EOF
   513 // EOF
   414 
   514