FCL/sf/app/commonemail: comparison emailservices/emailserver/cmailhandlerplugin/src/cmailcpshandler.cpp

equal deleted inserted replaced

-:e1b6206813b4
+:72d484772ca6
 /*
 * Copyright (c) 2008 - 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <StringLoader.h>
 #include <emailwidget.rsg>
 #include <AknUtils.h>
 #include <apgcli.h>
 #include <centralrepository.h>
-#include <starterdomaincrkeys.h>
-#include <startupdomainpskeys.h>
 #include <emailobserverinterface.hrh>
 #include <emailobserverplugin.h>
 #include <memaildata.h>
 #include <memailmailboxdata.h>
 // ---------------------------------------------------------
 // CMailCpsHandler::CMailCpsHandler
 // ---------------------------------------------------------
 //
-CMailCpsHandler::CMailCpsHandler( MFSNotificationHandlerMgr& aOwner ) : CFSNotificationHandlerBase( aOwner )
+CMailCpsHandler::CMailCpsHandler( MFSNotificationHandlerMgr& aOwner ):
+CFSNotificationHandlerBase( aOwner ),
+iWaitingForNewMailbox(NULL)
 {
 FUNC_LOG;
 }
 // ---------------------------------------------------------
 void CMailCpsHandler::ConstructL()
 {
 FUNC_LOG;
 CFSNotificationHandlerBase::ConstructL();
 iEnv = CEikonEnv::Static( );
 SetObserving( ETrue );
 // Instantiate helper classes
 // Leaves if ContentPublishing service not found
 iLiwIf = CMailCpsIf::NewL(this);
 {
 FUNC_LOG;
 // Get current configuration from settings interface,
 // and pass it on to actual publisher interface
 iLiwIf->SetConfiguration( iSettings->Configuration() );
 TInt iiMax( iSettings->Mailboxes().Count() );
 for ( TInt ii = 0; ii < iiMax; ii++ )
 {
 CFSMailBox* mailbox( NULL );
 mailbox = MailClient().GetMailBoxByUidL( iSettings->Mailboxes()[ii] );
 else
 {
 CleanupStack::PushL( mailbox );
 CMailMailboxDetails* mailboxDetails = CreateMailboxDetailsL( *mailbox );
 CleanupStack::PushL( mailboxDetails );
 TBuf<KMaxDescLen> cid;
 TInt next(1);
 // Check if same mailbox is already in iAccountsArray once or more
 for ( TInt i = 0; i < iAccountsArray.Count(); i++ )
 {
 TInt id = (TInt)iAccountsArray[i]->iMailboxId.Id();
 if (id == mailboxId)
 {
 next++;
 }
 }
 iSettings->GetContentId(mailboxId, next, cid);
 mailboxDetails->SetWidgetInstance(cid);
 iAccountsArray.AppendL( mailboxDetails );
 CleanupStack::Pop( mailboxDetails );
 CleanupStack::PopAndDestroy( mailbox );
 }
 }
 }
 // ---------------------------------------------------------
 //
 CMailMailboxDetails* CMailCpsHandler::CreateMailboxDetailsL( CFSMailBox& aMailbox )
 {
 FUNC_LOG;
 // Create instance to return
 CMailMailboxDetails* details =
 CMailMailboxDetails::NewL( aMailbox.GetId(), aMailbox.GetName() );
 return details;
 }
 // ---------------------------------------------------------
 // Trying to keep callback interface non-leaving
 TRAP_IGNORE( InitializeL() );
 TRAP_IGNORE( InitializeExternalAccountsL() );
 // Update widget contents after settings change
 TRAP_IGNORE( UpdateFullL() );
+CleanWaitingForNewMailbox();
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::UpdateFullL
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::UpdateMailboxesL(TInt aInstance, const TDesC& aContentId)
 {
 FUNC_LOG;
-TInt row(1); // start from first row
+// Look up 3rd party plugin that handles this account
-TInt mailbox(0);
+CMailPluginProxy* plugin = GetExtPluginL( aContentId );
-TBool found( EFalse );
+if ( plugin ) // handle external 3rd party accounts
-// try to find mailbox with matching contentId
+{
-for ( mailbox = 0; mailbox < iAccountsArray.Count(); mailbox++ )
+// Publish its data
-{
+plugin->UpdateAccountL( aContentId );
-if ( !aContentId.Compare( *iAccountsArray[mailbox]->iWidgetInstance ) )
+}
-{
+else // handle internal accounts
-INFO_1("iAccountsArray.Count() == %d", iAccountsArray.Count());
+{
-found = ETrue;
+TInt row(1); // start from first row
-break;
+TInt mailbox(0);
-}
+TBool found( EFalse );
-}
+// try to find mailbox with matching contentId
+for ( mailbox = 0; mailbox < iAccountsArray.Count(); mailbox++ )
-// if contentId found from array, update the mailbox
+{
-if ( found )
+if ( !aContentId.Compare( *iAccountsArray[mailbox]->iWidgetInstance ) )
 {
-// Update fields from left to right
+INFO_1("iAccountsArray.Count() == %d", iAccountsArray.Count());
-UpdateMailBoxIconL( mailbox, aInstance, row );
+found = ETrue;
-UpdateMailboxNameL( mailbox, aInstance, row );
+break;
-UpdateIndicatorIconL( mailbox, aInstance, row );
+}
-row++;
+}
-UpdateMessagesL( mailbox, aInstance, 1, row);
-row++;
+// if contentId found from array, update the mailbox
-UpdateMessagesL( mailbox, aInstance, 2, row);
+if ( found )
+{
+// Update fields from left to right
+UpdateMailBoxIconL( mailbox, aInstance, row );
+UpdateMailboxNameL( mailbox, aInstance, row );
+UpdateIndicatorIconL( mailbox, aInstance, row );
+row++;
+UpdateMessagesL( mailbox, aInstance, 1, row);
+row++;
+UpdateMessagesL( mailbox, aInstance, 2, row);
+}
+else
+{
+// Clean mailbox name
+iLiwIf->PublishActiveMailboxNameL( aInstance, 1, KNullDesC );
+// Clean mailbox icon
+TFSMailMsgId mailBoxId; // id not essential here
+iLiwIf->PublishMailboxIconL( aInstance, 1, KNullIcon, mailBoxId);
+// Clean indicator icon
+iLiwIf->PublishIndicatorIconL( aInstance, 1, KNullIcon);
+// Clean message rows
+UpdateEmptyMessagesL( aInstance, 2 );
+UpdateEmptyMessagesL( aInstance, 3 );
+}
 }
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::UpdateMailboxNameL
 if ( aMailBoxNumber < iAccountsArray.Count() )
 {
 mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;
 CFSMailBox* mailbox( NULL );
 mailbox = MailClient().GetMailBoxByUidL( mailBoxId );
 if(mailbox)
 {
 mailBoxFound = ETrue;
 TFSMailMsgId folderId( mailbox->GetStandardFolderId( EFSInbox ) );
 delete mailbox;
 TBuf<KMaxDescLen> accountName;
 accountName.Append(*iAccountsArray[aMailBoxNumber]->iMailboxName);
 TInt unreadCount(GetUnreadCountL(iAccountsArray[aMailBoxNumber]->iMailboxId));
 if ( unreadCount > 0 )
 {
 // Use localisation format when displaying also unread messages
 // Arrays must be used when loc string contains indexed parameters
 CDesCArrayFlat* strings = new CDesCArrayFlat( 1 );
 CleanupStack::PushL( strings );
 strings->AppendL( accountName ); // replace "%0U" with mailbox name
 CArrayFix<TInt>* ints = new(ELeave) CArrayFixFlat<TInt>( 1 );
 CleanupStack::PushL( ints );
 ints->AppendL( unreadCount ); // replace "%1N" with number of unread messages
 HBufC* mailboxAndCount = StringLoader::LoadLC( R_EMAILWIDGET_TEXT_MAILBOX_AND_MAILCOUNT,
 *strings,
 *ints );
 iLiwIf->PublishActiveMailboxNameL(
 				        aWidgetInstance,
-aRowNumber, *mailboxAndCount,
+aRowNumber, *mailboxAndCount);
-iAccountsArray.Count(),
-mailBoxId, folderId);
 CleanupStack::PopAndDestroy(mailboxAndCount);
 CleanupStack::PopAndDestroy(ints);
 CleanupStack::PopAndDestroy(strings);
 }
 else
 {
 // show only mailbox name
 iLiwIf->PublishActiveMailboxNameL(
 				        aWidgetInstance,
-aRowNumber, accountName,
+aRowNumber, accountName);
-iAccountsArray.Count(),
-mailBoxId, folderId);
 }
 }
 }
 else if(!mailBoxFound)
 {
 // Publishing empty descriptor for rows that should not contain
 // anything on widget UI.
 iLiwIf->PublishActiveMailboxNameL( aWidgetInstance,
 		                                   aRowNumber,
-										   KNullDesC,
+										   KNullDesC);
-										   NULL,
-										   mailBoxId,
-										   folderId );
 }
 }
 // ---------------------------------------------------------
 void CMailCpsHandler::UpdateMessagesL( const TInt aMailBoxNumber,
 const TInt aWidgetInstance,
 const TInt aMessageNumber,
 const TInt aRow )
 {
 FUNC_LOG;
 if ( aMailBoxNumber < iAccountsArray.Count() )
 {
 TFSMailMsgId mailBoxId;
 mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;
 return;
 }
 CleanupStack::PushL( folder );
 TInt msgCount = folder->GetMessageCount();
 if(msgCount<1 || (msgCount == 1 && aRow == 3))
 {
 UpdateEmptyMessagesL( aWidgetInstance, aRow );
 CleanupStack::PopAndDestroy( folder );
 return;
 CleanupClosePushL( folderMessages );
 TFSMailDetails details( EFSMsgDataEnvelope );
 RArray<TFSMailSortCriteria> sorting;
 CleanupClosePushL( sorting );
 TFSMailSortCriteria sortCriteria;
 sortCriteria.iField = EFSMailSortByDate;
 sortCriteria.iOrder = EFSMailDescending;
 sorting.Append( sortCriteria );
 // List all or maximum number of messages
 MFSMailIterator* iterator = folder->ListMessagesL( details, sorting );
 CleanupDeletePushL( iterator ); // standard CleanupStack::PushL does not work with non-C-class pointer
 TFSMailMsgId dummy;
 iterator->NextL( dummy, aMessageNumber, folderMessages);
 TInt count (folderMessages.Count());
 if(!count || (count == 1 && aRow == 3))
 {
 UpdateEmptyMessagesL( aWidgetInstance, aRow );
 CleanupStack::PopAndDestroy( iterator );
 CleanupStack::PopAndDestroy( &sorting );
 CleanupStack::PopAndDestroy( &folderMessages );
 CleanupStack::PopAndDestroy( folder );
 msg = MailClient().GetMessageByUidL( mailBoxId, parentFolder, msgId, EFSMsgDataEnvelope );
 CleanupDeletePushL( msg );
 // Get sender information
 TBuf<KMaxDescLen> sender( NULL );
+TBuf<KMaxDescLen> subject( NULL );
+subject.Append(msg->GetSubject());
 CFSMailAddress* fromAddress = msg->GetSender();
 if ( fromAddress )
 {
 if ( IsValidDisplayName(fromAddress->GetDisplayName()) )
 {
 else
 {
 sender.Append(fromAddress->GetEmailAddress());
 }
 }
 // Get message time and format it correctly
 TTime msgTime = msg->GetDate();
 HBufC* timeString( NULL );
 timeString = GetMessageTimeStringL( msgTime );
 CleanupDeletePushL( timeString );
 // Publish message details
 PublishMessageL( aWidgetInstance,
 *msg,
 sender,
+subject,
 *timeString,
 aRow );
 CleanupStack::PopAndDestroy( timeString );
 CleanupStack::PopAndDestroy( msg );
 CleanupStack::PopAndDestroy( iterator );
 CleanupStack::PopAndDestroy( &sorting );
 CleanupStack::PopAndDestroy( &folderMessages );
 FUNC_LOG;
 // Get current local time
 TTime currentTime;
 currentTime.HomeTime();
 // Get universal time offset and add it to message time
 TLocale locale;
 TTimeIntervalSeconds universalTimeOffset( locale.UniversalTimeOffset() );
 aMessageTime += universalTimeOffset;
 // If daylight saving is on, add one hour offset to message time
 if ( locale.QueryHomeHasDaylightSavingOn() )
 {
 TTimeIntervalHours daylightSaving( 1 );
 aMessageTime += daylightSaving;
 }
 // Get datetime objects and compare dates
 TDateTime currentDate = currentTime.DateTime();
 TDateTime messageDate = aMessageTime.DateTime();
 HBufC* formatString( NULL );
 if ( currentDate.Year() == messageDate.Year()
 && currentDate.Month() == messageDate.Month()
 && currentDate.Day() == messageDate.Day())
 {
 // Message arrived today
 formatString = StringLoader::LoadLC( R_QTN_TIME_USUAL_WITH_ZERO );
 }
 else
 {
 // Message arrived earlier than today
 formatString = StringLoader::LoadLC( R_QTN_DATE_WITHOUT_YEAR_WITH_ZERO );
 }
 // Format time string using chosen time or date formatString
 TBuf<KMaxShortDateFormatSpec*2> timeString;
 TRAP_IGNORE( aMessageTime.FormatL( timeString, formatString->Des() ) );
 CleanupStack::PopAndDestroy( formatString );
 // If format fails, result is empty
 HBufC* result = timeString.Alloc();
 TPtr ptr = result->Des();
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
 return result;
 }
 // CMailCpsHandler::PublishMessageL
 //
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::PublishMessageL( TInt aWidgetInstance, CFSMailMessage& aMessage,
-const TDesC& aSenderName, const TDesC& aTime, TInt aRow )
+const TDesC& aSenderName, const TDesC& aSubject,
+const TDesC& aTime, TInt aRow )
 {
 FUNC_LOG;
 TFSMailMsgId msgId( aMessage.GetMessageId() );
 iLiwIf->PublishMailboxIconL( aWidgetInstance, aRow, GetMailIcon( &aMessage ), msgId );
 iLiwIf->PublishMailDetailL( aWidgetInstance, aRow, aSenderName, ESender );
+iLiwIf->PublishMailDetailL( aWidgetInstance, aRow, aSubject, ESubject );
 iLiwIf->PublishMailDetailL( aWidgetInstance, aRow, aTime, ETime );
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::UpdateEmptyMessagesL
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::UpdateEmptyMessagesL( const TInt aWidgetInstance,
 const TInt aRow )
 {
 FUNC_LOG;
 TFSMailMsgId mailBoxId; // id not essential here
 iLiwIf->PublishMailDetailL(
 aWidgetInstance,
 aRow,
 KNullDes,
 ESender);
+iLiwIf->PublishMailDetailL(
+aWidgetInstance,
+aRow,
+KNullDes,
+ESubject);
 iLiwIf->PublishMailboxIconL(
 aWidgetInstance,
 aRow,
 KNullIcon,
 mailBoxId);
 iLiwIf->PublishMailDetailL(
 aWidgetInstance,
 aRow,
 KNullDes,
 ETime);
 }
-/*
-// ---------------------------------------------------------
-// CMailCpsHandler::UpdateConnectStateL
-// ---------------------------------------------------------
-//
-void CMailCpsHandler::UpdateConnectStateL( const TInt aMailBoxNumber, const TInt aRowNumber )
-{
-FUNC_LOG;
-if ( aMailBoxNumber < iAccountsArray.Count() )
-{
-TFSMailMsgId mailBoxId;
-mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;
-CFSMailBox* mailbox( NULL );
-mailbox = MailClient().GetMailBoxByUidL( mailBoxId );
-if(mailbox)
-{
-iLiwIf->PublishConnectIconL(mailbox->GetMailBoxStatus(), aRowNumber);
-}
-}
-else
-{
-iLiwIf->PublishConnectIconL( EFSMailBoxOffline, aRowNumber );
-}
-}
-*/
 // ---------------------------------------------------------
 // CMailCpsHandler::UpdateMailBoxIconL
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::UpdateMailBoxIconL( const TInt aMailBoxNumber,
 const TInt aWidgetInstance,
 const TInt aRowNumber )
 {
 FUNC_LOG;
 TFSMailMsgId mailBoxId; // id required only for getting branded mailbox icon
 if ( aMailBoxNumber < iAccountsArray.Count() )
 {
 mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;
 iLiwIf->PublishMailboxIconL( aWidgetInstance,
 		                             aRowNumber,
 									 EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account,
 									 mailBoxId);
 }
 else
 {
 iLiwIf->PublishMailboxIconL( aWidgetInstance, aRowNumber, KNullIcon, mailBoxId);
 }
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::UpdateIndicatorIconL
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::UpdateIndicatorIconL( const TInt aMailBoxNumber,
 const TInt aWidgetInstance,
 const TInt aRowNumber )
 {
 FUNC_LOG;
 if ( aMailBoxNumber < iAccountsArray.Count() )
 {
 TFSMailMsgId mailBoxId;
 mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;
 if ( iSettings->GetNewMailState( mailBoxId ) )
 {
 iLiwIf->PublishIndicatorIconL( aWidgetInstance,
 aRowNumber,
 EMbmCmailhandlerpluginQgn_stat_message_mail_uni );
 }
 else if( !IsOutboxEmptyL(mailBoxId) )
 {
 iLiwIf->PublishIndicatorIconL( aWidgetInstance,
 aRowNumber,
 EMbmCmailhandlerpluginQgn_indi_cmail_outbox_msg);
 }
 else
 {
 iLiwIf->PublishIndicatorIconL( aWidgetInstance,
 aRowNumber,
 KNullIcon);
 }
 }
 else
 {
 iLiwIf->PublishIndicatorIconL( aWidgetInstance,
 aRowNumber,
 KNullIcon);
 }
 }
-/*
-// ---------------------------------------------------------
-// CMailCpsHandler::ClearMessageTimeL
-// ---------------------------------------------------------
-//
-void CMailCpsHandler::ClearMessageTimeL( const TInt aRowNumber )
-{
-FUNC_LOG;
-iLiwIf->PublishMailDetailL(
-aRowNumber,
-KNullDes,
-ETime);
-}
-*/
 // ---------------------------------------------------------
 // CMailCpsHandler::CapabilitiesToContinueL
 // ---------------------------------------------------------
 //
 // Is the mailbox in our list
 switch ( aEvent )
 {
 case TFSEventNewMailbox:
 {
-//            HandleNewMailboxEventL( aMailbox );
+HandleNewMailboxEventL( aMailbox );
 break;
 }
 case TFSEventMailboxRenamed:
 {
 HandleMailboxRenamedEventL( aMailbox );
 {
 HandleMailboxDeletedEventL( aMailbox );
 UpdateFullL();
 break;
 }
-case TFSEventMailboxSettingsChanged:
-{
-//            HandleMailboxDeletedEventL( aMailbox );
-//            HandleNewMailboxEventL( aMailbox );
-break;
-}
 case TFSEventNewMail:
 {
 HandleNewMailEventL( aMailbox, aParam1, aParam2 );
 UpdateFullL();
 break;
 {
 HandleMailDeletedEventL( aMailbox, aParam1, aParam2 );
 UpdateFullL();
 break;
 }
-case TFSEventMailChanged:
+default:
 {
-HandleMailChangedEventL( aMailbox, aParam1, aParam2 );
 break;
 }
-case TFSEventNewFolder:
-{
-HandleNewFolderEventL( aMailbox, aParam1, aParam2 );
-break;
-}
-default:
-{
-break;
-}
 }
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::HandleNewMailboxEventL
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::HandleNewMailboxEventL( const TFSMailMsgId aMailbox )
 {
 FUNC_LOG;
+if (iWaitingForNewMailbox)
-// Check that max mailbox count is not already reached
+{
-const TInt iiMax( iAccountsArray.Count() );
+iSettings->AssociateWidgetToSetting( iWaitingForNewMailbox->Des(), aMailbox );
-if( iiMax >= iSettings->MaxMailboxCount() )
+}
-{
-return;
-}
-// Check that mailbox is not already in widget
-for ( TInt ii = 0; ii < iiMax; ii++ )
-{
-if( iAccountsArray[ii]->iMailboxId.Id() == aMailbox.Id() )
-{
-return;
-}
-}
-CFSMailBox* mailbox( NULL );
-mailbox = MailClient().GetMailBoxByUidL( aMailbox );
-if ( !mailbox )
-{
-return; // nothing that could be done
-}
-else
-{
-CleanupStack::PushL( mailbox );
-CMailMailboxDetails* mailboxDetails = CreateMailboxDetailsL( *mailbox );
-CleanupStack::PushL( mailboxDetails );
-iAccountsArray.AppendL( mailboxDetails );
-CleanupStack::Pop( mailboxDetails );
-CleanupStack::PopAndDestroy( mailbox );
-}
-iSettings->AddMailboxL( aMailbox );
 }
 // ---------------------------------------------------------
 // CMailCpsHandler::HandleMailboxRenamedEventL
 // ---------------------------------------------------------
 //
 void CMailCpsHandler::HandleNewMailEventL(
 TFSMailMsgId aMailbox, TAny* aParam1, TAny* aParam2 )
 {
 FUNC_LOG;
 iSettings->ToggleWidgetNewMailIconL( ETrue, aMailbox );
 // Basic assertions
 if ( !aParam1 || !aParam2 )
 {
 User::Leave( KErrArgument );
 }
 // Find mailbox instance from array
 CMailMailboxDetails* mailbox = FindMailboxDetails( aMailbox );
 if ( !mailbox )
 {
 return;
 CFSMailMessage* msg( NULL );
 for ( TInt ii = 0; ii < iiMax; ii++ )
 {
 msgId = (*newEntries)[ii];
 msg = MailClient().GetMessageByUidL(
 aMailbox, *parentFolder, (*newEntries)[ii], EFSMsgDataEnvelope );
 if ( !msg )
 {
 User::Leave( KErrNotFound );
 }
 {
 // Ignore already known messages
 CleanupStack::PopAndDestroy( msg );
 continue;
 }
 CMailMessageDetails* messageDetails = CMailMessageDetails::NewL(
 msg->GetMessageId(),
 mailbox,
 msg->GetSender()->GetEmailAddress(),
 msg->GetSubject(),
 CleanupClosePushL( *entries );
 if ( entries->Count() == 0 )
 {
 User::Leave( KErrArgument );
 }
 // Find correct mailbox
 CMailMailboxDetails* mailbox = FindMailboxDetails( aMailbox );
 if ( !mailbox )
 {
 //<Cmail>
 CleanupStack::PopAndDestroy( entries );
 //<Cmail>
 return;
 }
 const TInt iiMax( entries->Count() );
 const TInt jjMax( mailbox->iMessageDetailsArray.Count() );
 // Loop through entries in the array
 for ( TInt ii = 0; ii < iiMax; ii++ )
 {
 CleanupStack::PopAndDestroy( entries );
 }
 // ---------------------------------------------------------
-// CMailCpsHandler::HandleMailChangedEventL
-// ---------------------------------------------------------
-//
-void CMailCpsHandler::HandleMailChangedEventL(
-TFSMailMsgId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/ )
-{
-FUNC_LOG;
-}
-// ---------------------------------------------------------
-// CMailCpsHandler::HandleNewFolderEventL
-// ---------------------------------------------------------
-//
-void CMailCpsHandler::HandleNewFolderEventL(
-TFSMailMsgId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/ )
-{
-FUNC_LOG;
-}
-// ---------------------------------------------------------
 // CMailCpsHandler::GetUnreadCountL
 // ---------------------------------------------------------
 //
 TInt CMailCpsHandler::GetUnreadCountL(TFSMailMsgId aMailbox)
 {
 FUNC_LOG;
 CFSMailBox* mailbox( NULL );
 TInt unread (0);
 mailbox = MailClient().GetMailBoxByUidL( aMailbox );
 if(mailbox)
 {
 TFSMailMsgId folderId( mailbox->GetStandardFolderId( EFSInbox ) );
 // Check that folder is correct
 CFSMailFolder* folder = MailClient().GetFolderByUidL( aMailbox, folderId );
 if ( !folder )
 {
 return KErrNotFound;
 }
 CleanupStack::PushL( folder );
 unread = folder->GetUnreadCount();
 CleanupStack::PopAndDestroy( folder );
 if (unread > KMaxUnreadCount)
 {
 unread = KMaxUnreadCount;
 }
 }
 FUNC_LOG;
 CFSMailBox* mailbox( NULL );
 TInt unseen (0);
 mailbox = MailClient().GetMailBoxByUidL( aMailbox );
 if(mailbox)
 {
 TFSMailMsgId folderId( mailbox->GetStandardFolderId( EFSInbox ) );
 // Check that folder is correct
 CFSMailFolder* folder = MailClient().GetFolderByUidL( aMailbox, folderId );
 if ( !folder )
 {
 return KErrNotFound;
 }
 CleanupStack::PushL( folder );
 unseen = folder->GetUnseenCount();
 CleanupStack::PopAndDestroy( folder );
 if (unseen > KMaxUnreadCount)
 {
 unseen = KMaxUnreadCount;
 }
 }
 CFSMailBox* mailbox( NULL );
 TBool ret(ETrue);
 TInt msgCount(0);
 mailbox = MailClient().GetMailBoxByUidL( aMailbox );
 if(mailbox)
 {
 TFSMailMsgId folderId( mailbox->GetStandardFolderId( EFSOutbox ) );
 // Check that folder is correct
 CFSMailFolder* folder = MailClient().GetFolderByUidL( aMailbox, folderId );
 if ( !folder )
 {
 return KErrNotFound;
 }
 CleanupStack::PushL( folder );
 msgCount = folder->GetMessageCount();
 if ( msgCount<1 )
 {
 CleanupStack::PopAndDestroy( folder );
 return ret;
 }
 TFSMailDetails details( EFSMsgDataEnvelope );
 RArray<TFSMailSortCriteria> sorting;
 CleanupClosePushL( sorting );
 TFSMailSortCriteria sortCriteria;
 sortCriteria.iField = EFSMailDontCare;
 sortCriteria.iOrder = EFSMailDescending;
 sorting.Append( sortCriteria );
 // List all or maximum number of messages
 MFSMailIterator* iterator = folder->ListMessagesL( details, sorting );
 CleanupStack::PopAndDestroy( &sorting );
 CleanupDeletePushL( iterator );
 RPointerArray<CFSMailMessage> messages;
 CleanupClosePushL( messages );
-TInt amount( msgCount );
+iterator->NextL( TFSMailMsgId(), msgCount, messages );
-iterator->NextL( TFSMailMsgId(), amount, messages );
+TInt arrayCount(messages.Count());
-for (TInt i = 0; i < msgCount; i++)
+for (TInt i = 0; i < arrayCount; i++)
 {
-TFSMailMsgId msgId = messages[0]->GetMessageId();
+TFSMailMsgId msgId = messages[i]->GetMessageId();
 CFSMailMessage* msg( NULL );
 msg = MailClient().GetMessageByUidL( aMailbox, folderId, msgId, EFSMsgDataEnvelope );
-CleanupDeletePushL( msg );
+			if (msg)
-TFSMailMsgId mailboxId = msg->GetMailBoxId();
+{
-CleanupStack::PopAndDestroy( msg );
+CleanupDeletePushL( msg );
+TFSMailMsgId mailboxId = msg->GetMailBoxId();
-if (mailboxId == aMailbox)
+CleanupStack::PopAndDestroy( msg );
-{
-ret = EFalse;
+if (mailboxId == aMailbox)
-break;
+{
+ret = EFalse;
+break;
+}
 }
 }
 CleanupStack::PopAndDestroy( &messages );
 CleanupStack::PopAndDestroy( iterator );
 // -----------------------------------------------------------------------------
 // CMailCpsHandler::GetUnreadMsgIcon
 // -----------------------------------------------------------------------------
 TInt CMailCpsHandler::GetUnreadMsgIcon( CFSMailMessage* aMsg )
 {
 FUNC_LOG;
 TInt icon(EMbmCmailhandlerpluginQgn_indi_cmail_unread);
 // Unread calendar invitation
 if ( aMsg->IsFlagSet( EFSMsgFlag_CalendarMsg ))
 {
 icon = GetUnreadCalMsgIcon( aMsg );
 }
 else    // Normal message icons
 {
 // Check whether msg has attachment or not
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments )) // Has attachments
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_forwarded_attach_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_attach_low_prio;
 }
 }
 else // Normal priority, has attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_replied_attach;
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Forwarded ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_attach;
 }
 }
 }
 else // No attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Important )) // High priority, no attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_forwarded_high_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_high_prio;
 }
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, no attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_forwarded_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_low_prio;
 }
 }
 else // Normal priority, no attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_replied;
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Forwarded ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_unread_forwarded;
 }
 }
 }
 }
 return icon;
 }
 // -----------------------------------------------------------------------------
 // CMailCpsHandler::GetReadMsgIcon
 // -----------------------------------------------------------------------------
 TInt CMailCpsHandler::GetReadMsgIcon( CFSMailMessage* aMsg )
 {
 FUNC_LOG;
 TInt icon(EMbmCmailhandlerpluginQgn_indi_cmail_read);
 if ( aMsg->IsFlagSet( EFSMsgFlag_CalendarMsg ))
 {
 icon = GetReadCalMsgIcon( aMsg );
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_forwarded_attach_high_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_attach_high_prio;
 }
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, has attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_forwarded_attach_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_attach_low_prio;
 }
 }
 else // Normal priority, has attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_replied_attach;
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Forwarded ) )
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_forwarded_attach;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_attach;
 }
 }
 }
 else // No attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Important )) // High priority, no attachments
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_forwarded_high_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_high_prio;
 }
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, no attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_forwarded_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_low_prio;
 }
 }
 else // Normal priority, no attachments
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Answered ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_read_replied;
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Forwarded ) )
 // -----------------------------------------------------------------------------
 // CMailCpsHandler::GetUnreadCalMsgIcon
 // -----------------------------------------------------------------------------
 TInt CMailCpsHandler::GetUnreadCalMsgIcon( CFSMailMessage* aMsg )
 {
 FUNC_LOG;
 TInt icon(0);
 if ( aMsg->IsFlagSet( EFSMsgFlag_Important ) )
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread_attachments_high_prio ;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread_high_prio;
 }
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Low ) )
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread_attachments_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread_low_prio;
 }
 }
 else
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread_attachments;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_unread;
 }
 }
 return icon;
 }
 // -----------------------------------------------------------------------------
 // CMailCpsHandler::GetReadCalMsgIcon
 // -----------------------------------------------------------------------------
 TInt CMailCpsHandler::GetReadCalMsgIcon( CFSMailMessage* aMsg )
 {
 FUNC_LOG;
 TInt icon(0);
 if ( aMsg->IsFlagSet( EFSMsgFlag_Important ) )
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read_attachments_high_prio ;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read_high_prio;
 }
 }
 else if ( aMsg->IsFlagSet( EFSMsgFlag_Low ) )
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read_attachments_low_prio;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read_low_prio;
 }
 }
 else
 {
 if ( aMsg->IsFlagSet( EFSMsgFlag_Attachments ) )
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read_attachments;
 }
 else
 {
 icon = EMbmCmailhandlerpluginQgn_indi_cmail_calendar_event_read;
 }
 }
 return icon;
 }
 // -----------------------------------------------------------------------------
 (aDisplayName.Find(KAt)) &&
 (aDisplayName.Find(KDot)))
 {
 return EFalse;
 }
 return ETrue;
 }
 // -----------------------------------------------------------------------------
 // CMailCpsHandler::IsDuplicate
 //  CMailCpsHandler::LaunchWidgetSettingsL()
 // -----------------------------------------------------------------------------
 //
 void CMailCpsHandler::LaunchWidgetSettingsL( const TDesC& aContentId )
 {
 FUNC_LOG;
 RApaLsSession appArcSession;
 CleanupClosePushL( appArcSession );
 User::LeaveIfError( appArcSession.Connect( ) );
 TApaAppInfo appInfo;
 commandLine->SetDocumentNameL(KNullDesC);
 commandLine->SetExecutableNameL(fullFileName);
 commandLine->SetCommandL( EApaCommandRun );
 commandLine->SetProcessEnvironmentL(process);
 CleanupStack::PopAndDestroy(commandLine);
 process.Resume();
 process.Close();
 CleanupStack::PopAndDestroy(&appArcSession);
+SetWaitingForNewMailbox( aContentId );
 }
 // -----------------------------------------------------------------------------
 //  CMailCpsHandler::LaunchEmailUIL()
 // -----------------------------------------------------------------------------
 // Is the contentId related to internal mailbox or external?
 if( nativeMailboxId )
 {
 TUid mailBoxUid;
 mailBoxUid.iUid = nativeMailboxId;
 TFSMailMsgId mailBoxId;
 mailBoxId.SetId(mailBoxUid.iUid);
 TUid pluginUid;
 pluginUid.iUid = iSettings->GetPluginUidByContentId(aContentId);
 mailBoxId.SetPluginId(pluginUid);
 CFSMailBox* mailBox = MailClient().GetMailBoxByUidL( mailBoxId );
 CleanupStack::PushL( mailBox );
 if ( mailBox )
 {
 TFSMailMsgId inboxFolderId = mailBox->GetStandardFolderId( EFSInbox );
 TMailListActivationData tmp;
 tmp.iFolderId = inboxFolderId;
 tmp.iMailBoxId = mailBoxId;
 const TPckgBuf<TMailListActivationData> pkgOut( tmp );
-iEnv->EikAppUi()->ActivateViewL( TVwsViewId(KUidEmailUi, KMailListId),
+iEnv->EikAppUi()->ActivateViewL(
-KStartListWithFolderId,
+TVwsViewId(KUidEmailUi, KMailListId),
-pkgOut);
+KStartListWithFolderIdFromHomeScreen, pkgOut);
 }
 CleanupStack::PopAndDestroy( mailBox );
 }
 else
 {
 LaunchExtAppL( aContentId );
 }
 }
 // -----------------------------------------------------------------------------
-//  CMailCpsHandler::LaunchEmailUIL()
+//  CMailCpsHandler::LaunchEmailWizardL()
 // -----------------------------------------------------------------------------
 //
-void CMailCpsHandler::LaunchEmailWizardL()
+void CMailCpsHandler::LaunchEmailWizardL( const TDesC& aContentId )
 {
 FUNC_LOG;
 TUid viewUid(KNullUid);
 iEnv->EikAppUi()->ActivateViewL( TVwsViewId(KUidWizardApp, KUidEmailWizardView),
 viewUid,
 KNullDesC8);
+SetWaitingForNewMailbox( aContentId );
 }
 // -----------------------------------------------------------------------------
 //  CMailCpsHandler::LaunchExtAppL()
 // -----------------------------------------------------------------------------
 {
 plugin = iExternalPlugins[i];
 }
 }
 return plugin;
-}
-// -----------------------------------------------------------------------------
-//  CMailCpsHandler::UpdateExtAccountL
-// -----------------------------------------------------------------------------
-//
-void CMailCpsHandler::UpdateExtAccountL( const TDesC& aContentId )
-{
-FUNC_LOG;
-// Look up plugin that handles this account
-CMailPluginProxy* plugin = GetExtPluginL( aContentId );
-if ( plugin )
-{
-// Publish its data
-plugin->UpdateAccountL( aContentId );
-}
-}
-// ---------------------------------------------------------------------------
-// CMailCpsHandler::AssociateWidget
-// ---------------------------------------------------------------------------
-//
-TBool CMailCpsHandler::AssociateWidgetToSetting( const TDesC& aContentId )
-{
-FUNC_LOG;
-return iSettings->AssociateWidgetToSetting( aContentId );
 }
 // ---------------------------------------------------------------------------
 // CMailCpsHandler::DissociateWidget
 // ---------------------------------------------------------------------------
 //
 void CMailCpsHandler::DissociateWidgetFromSettingL( const TDesC& aContentId )
 {
 FUNC_LOG;
-//Do not dissociate if device is shutting down
+iSettings->DissociateWidgetFromSettingL( aContentId );
-TInt status( 0 );
-RProperty::Get( KPSUidStartup, KPSGlobalSystemState, status );
-if (status != ESwStateShuttingDown)
-{
-iSettings->DissociateWidgetFromSettingL( aContentId );
-}
 }
 // ---------------------------------------------------------------------------
 // CMailCpsHandler::TotalMailboxCount
 // ---------------------------------------------------------------------------
 for ( TInt i = 0; i < plugins.Count(); i++ )
 {
 TUid implUid = plugins[i]->ImplementationUid();
 INFO_1("Instantiating plugin %d", implUid.iUid);
 EmailInterface::CEmailObserverPlugin* plugin =
 EmailInterface::CEmailObserverPlugin::NewL( implUid, this );
 MEmailData& data( plugin->EmailDataL() );
 totalMailboxCount += data.MailboxesL().Count();
 }
 CleanupStack::PopAndDestroy(); // plugins
 return totalMailboxCount;
-}
-// ---------------------------------------------------------------------------
-// CMailCpsHandler::ManualAccountSelectionL
-// ---------------------------------------------------------------------------
-//
-void CMailCpsHandler::ManualAccountSelectionL( const TDesC& aContentId )
-{
-FUNC_LOG;
-if ( FirstBootL() )
-{
-if (!iSettings->FindFromContentIdListL(aContentId))
-{
-iSettings->AddToContentIdListL(aContentId);
-}
-}
-else
-{
-if (!iSettings->FindFromContentIdListL(aContentId))
-{
-iSettings->AddToContentIdListL(aContentId);
-if ( TotalMailboxCountL() )
-{
-LaunchWidgetSettingsL(aContentId);
-}
-else
-{
-LaunchEmailWizardL();
-}
-}
-}
-}
-// ---------------------------------------------------------------------------
-// CMailCpsHandler::FirstBootL
-// ---------------------------------------------------------------------------
-TBool CMailCpsHandler::FirstBootL()
-{
-FUNC_LOG;
-TInt value( 0 );
-TBool ret(EFalse);
-CRepository* repository(NULL);
-TRAPD( err, repository = CRepository::NewL( KCRUidStartup ) );
-if ( err == KErrNone )
-{
-err = repository->Get( KStartupFirstBoot, value );
-}
-delete repository;
-if (!value)
-{
-ret = ETrue;
-}
-return ret;
 }
 // ---------------------------------------------------------------------------
 // CMailCpsHandler::EmailObserverEvent
 // ---------------------------------------------------------------------------
 void CMailCpsHandler::EmailObserverEvent( EmailInterface::MEmailData& /*aData*/ )
 {
+FUNC_LOG;
 // Nothing to do
 }
+// -----------------------------------------------------------------------------
+//  CMailCpsHandler::SetWaitingForNewMailbox()
+// -----------------------------------------------------------------------------
+//
+void CMailCpsHandler::SetWaitingForNewMailbox( const TDesC& aContentId )
+{
+FUNC_LOG;
+HBufC* newCid = aContentId.Alloc();
+if ( newCid )
+{
+delete iWaitingForNewMailbox;
+iWaitingForNewMailbox = newCid;
+}
+}
+// -----------------------------------------------------------------------------
+//  CMailCpsHandler::CleanWaitingForNewMailbox()
+// -----------------------------------------------------------------------------
+//
+void CMailCpsHandler::CleanWaitingForNewMailbox()
+{
+FUNC_LOG;
+	if (iWaitingForNewMailbox)
+{
+delete iWaitingForNewMailbox;
+iWaitingForNewMailbox = NULL;
+}
+}

branch	RCL_3
changeset 31	72d484772ca6
parent 8	e1b6206813b4
child 17	8592a65ad3fb