/*
* Copyright (c) 2005 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".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Provides Class methods for handling message entries and using CMsvSession
*
*/
// INCLUDES
#include "cmrutilsmsvhelper.h"
#include "cmrmailboxinfo.h"
#include <SenduiMtmUids.h>
#include <cemailaccounts.h>
#include <smtpset.h>
#include <imapset.h>
#include <pop3set.h>
#include <MuiuMsvUiServiceUtilities.h>
#include <MeetingRequestIds.hrh>
#include <mtclbase.h>
#include <mtclreg.h>
#include <utf.h>
// ========================= MEMBER FUNCTIONS ================================
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::NewL
// Symbian two-phased constructor.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
CMRUtilsMsvHelper* CMRUtilsMsvHelper::NewL(
CMsvSession* aSession,
MMsvSessionObserver& aParentObserver )
{
CMRUtilsMsvHelper* self =
new( ELeave ) CMRUtilsMsvHelper( aSession, aParentObserver );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::CMRUtilsMsvHelper
// Default constructor
// ----------------------------------------------------------------------------
//
CMRUtilsMsvHelper::CMRUtilsMsvHelper(
CMsvSession* aSession,
MMsvSessionObserver& aParentObserver )
: iParentObserver( aParentObserver ),
iSession( aSession ),
iOwnSession( aSession ? EFalse : ETrue ),
iEmailAddr(NULL)
{
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::~CMRUtilsMsvHelper
// Destructor.
// ----------------------------------------------------------------------------
//
CMRUtilsMsvHelper::~CMRUtilsMsvHelper()
{
iMRMailBoxes.ResetAndDestroy();
delete iMtmReg;
if ( iOwnSession )
{
if(iSession)
{
delete iSession;
}
}
else if ( iSession )
{ // just remove observer
iSession->RemoveObserver( *this );
}
delete iEmailSettings;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::ConstructL
// Symbian OS default constructor
// ----------------------------------------------------------------------------
//
void CMRUtilsMsvHelper::ConstructL()
{
if ( iSession )
{ // if existing session was given as construction parameter,
// then add observer manually
iSession->AddObserverL( *this );
}
// Create session if doesn't exist yet:
EnsureSessionExistsL();
FindMRMailBoxesL();
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::MRMailBoxes
// returns array of mailbox.
// ----------------------------------------------------------------------------
//
const RPointerArray<CMRMailBoxInfo>& CMRUtilsMsvHelper::MRMailBoxes() const
{
return iMRMailBoxes;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::MRMailBoxInfoL
// returns mailbox info
// ----------------------------------------------------------------------------
//
const CMRMailBoxInfo* CMRUtilsMsvHelper::MRMailBoxInfoL(
TInt aEntryId ) const
{
CMRMailBoxInfo* info( NULL );
TInt count( iMRMailBoxes.Count() );
for ( TInt i( 0 ); i < count; ++i )
{
if ( iMRMailBoxes[i]->EntryId() == aEntryId )
{
info = iMRMailBoxes[i];
break;
}
}
return info;
}
// TODO: siirrä tämä utilsimpliin
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::ListMRMailBoxesL
// lists all the mailboxes available.
// ----------------------------------------------------------------------------
//
void CMRUtilsMsvHelper::ListMRMailBoxesL(
RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )
{
EnsureSessionExistsL();
aMailBoxes.Reset();
TInt count( iMRMailBoxes.Count() );
for ( TInt i( 0 ); i < count; ++i )
{
CMRMailboxUtils::TMailboxInfo info;
info.iName.Set( iMRMailBoxes[i]->Name() );
info.iEmailAddress.Set( iMRMailBoxes[i]->Address() );
info.iMtmUid = iMRMailBoxes[i]->MtmUid();
info.iEntryId = iMRMailBoxes[i]->EntryId();
aMailBoxes.AppendL( info );
}
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::ExtensionL
// extension API.
// ----------------------------------------------------------------------------
//
TAny* CMRUtilsMsvHelper::ExtensionL( TUid /*aExtensionUid*/ )
{
return NULL;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::MsvSessionL
// returns session.
// ----------------------------------------------------------------------------
//
CMsvSession& CMRUtilsMsvHelper::MsvSessionL()
{
EnsureSessionExistsL();
return *iSession;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::EMailAddressL
// ----------------------------------------------------------------------------
//
//TBuf<KMREmailAddrLength> CMRUtilsMsvHelper::EMailAddressL( TMsvEntry& entry )
void CMRUtilsMsvHelper::EMailAddressL( TMsvEntry& entry )
{
EnsureSessionExistsL();
// TBuf<KMREmailAddrLength> emailAddr;
if ( entry.iMtm.iUid == KSenduiMtmImap4UidValue ||
entry.iMtm.iUid == KSenduiMtmPop3UidValue ||
entry.iMtm.iUid == KSenduiMtmSyncMLEmailUidValue )
{
// Read e-mail address from SMTP settings:
TMsvId smtpId = CorrespondingSmtpServiceL( entry );
CImSmtpSettings* smtpSettings = SmtpSettingsLC( smtpId );
iEmailAddr = smtpSettings->EmailAddress();
CleanupStack::PopAndDestroy( smtpSettings );
}
else if ( IsMRCapableL( entry.iMtm ) )
{ // 3rd party mtm types -> query from client mtm
CBaseMtm* mtm = iMtmReg->NewMtmL( entry.iMtm );
CleanupStack::PushL( mtm );
CMsvEntrySelection* selection = new( ELeave ) CMsvEntrySelection();
CleanupStack::PushL( selection );
selection->AppendL( entry.Id() );
RBuf8 addrData;
CleanupClosePushL( addrData );
addrData.CreateL( KMREmailAddrLength );
mtm->InvokeSyncFunctionL( KMTMMailAddressRequestFunctionId,
*selection,
addrData );
if ( addrData.Length() > 0 )
{
User::LeaveIfError( CnvUtfConverter::ConvertToUnicodeFromUtf8(
iEmailAddr, addrData ) );
}
CleanupStack::PopAndDestroy( 3 ); // addrData, selection, mtm
}
else
{ // we can't resolve email address for other types, and that's fine
User::Leave( KErrNotSupported );
}
// return emailAddr;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::CorrespondingSmtpServiceL
// returns the smtp id.
// ----------------------------------------------------------------------------
//
TMsvId CMRUtilsMsvHelper::CorrespondingSmtpServiceL( TMsvEntry& entry ) const
{
TMsvId smtpId( KMsvNullIndexEntryId );
switch ( entry.iMtm.iUid )
{
case KSenduiMtmImap4UidValue: // flow through
case KSenduiMtmPop3UidValue:
{
// In these cases smtp entry is available in iRelatedId:
smtpId = entry.iRelatedId;
break;
}
case KSenduiMtmSmtpUidValue:
case KSenduiMtmSyncMLEmailUidValue:
{
// In these cases we already know the msvid for the smtp settings
// (for syncml there is also smtp settings!):
smtpId = entry.Id();
break;
}
default:
{
User::Leave( KErrNotSupported );
break;
}
}
return smtpId;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::SmtpSettingsLC
// returns smtp settings.
// ----------------------------------------------------------------------------
//
CImSmtpSettings* CMRUtilsMsvHelper::SmtpSettingsLC( TMsvId aSmtpService )
{
// TODO: onko tässä lazyssa järkeä?
if ( !iEmailSettings )
{ // Lazy instantiation of iEmailSettings
iEmailSettings = CEmailAccounts::NewL();
}
TSmtpAccount smtpAccount;
iEmailSettings->GetSmtpAccountL( aSmtpService, smtpAccount );
CImSmtpSettings* smtpSettings = new( ELeave ) CImSmtpSettings();
CleanupStack::PushL( smtpSettings );
iEmailSettings->LoadSmtpSettingsL( smtpAccount, *smtpSettings );
return smtpSettings;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::IsMRCapableL
// returns ETrue if MRCapable, EFalse otherwise.
// ----------------------------------------------------------------------------
//
TBool CMRUtilsMsvHelper::IsMRCapableL( TUid aMtmUid )
{
TBool retVal( EFalse );
if ( aMtmUid.iUid == KSenduiMtmImap4UidValue ||
aMtmUid.iUid == KSenduiMtmPop3UidValue ||
aMtmUid.iUid == KSenduiMtmSyncMLEmailUidValue )
{
retVal = ETrue;
}
else if ( aMtmUid.iUid == KSenduiMtmSmtpUidValue )
{ // don't consider smtp's here, corresponding imap/pop boxes only
retVal = EFalse;
}
else
{
// we can create and destroy mtm without performance loss since registry
// unloads them only if unused for a period of time
CBaseMtm* mtm = iMtmReg->NewMtmL( aMtmUid );
CleanupStack::PushL( mtm );
TInt dummyResponse( 0 );
TInt result( mtm->QueryCapability(
TUid::Uid( KMtmUiSupportMeetingRequest ), dummyResponse ) );
CleanupStack::PopAndDestroy( mtm );
retVal = ( ( result == KErrNone ) ? ETrue : EFalse );
}
return retVal;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::EnsureSessionExistsL
// ensures the session existense, creates if not exists.
// ----------------------------------------------------------------------------
//
void CMRUtilsMsvHelper::EnsureSessionExistsL()
{
if ( !iSession )
{
iSession = CMsvSession::OpenSyncL( *this );
iOwnSession = ETrue;
}
if ( !iMtmReg )
{
iMtmReg = CClientMtmRegistry::NewL( *iSession );
}
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::HandleSessionEventL
// ----------------------------------------------------------------------------
//
void CMRUtilsMsvHelper::HandleSessionEventL(
TMsvSessionEvent aEvent,
TAny* aArg1,
TAny* aArg2,
TAny* aArg3 )
{
switch ( aEvent )
{
case EMsvCloseSession:
case EMsvServerTerminated:
{
delete iMtmReg;
iMtmReg = NULL;
if ( iOwnSession )
{
delete iSession;
}
iSession = NULL; // New session constructed only if needed
break;
}
case EMsvEntriesCreated:
{
CMsvEntrySelection* entries =
static_cast<CMsvEntrySelection*>( aArg1 );
if ( AddToListIfMRMailBoxesL( *entries ) )
{ // at least MR mailbox created
iParentObserver.HandleSessionEventL( aEvent,
aArg1,
aArg2,
aArg3 );
}
break;
}
case EMsvEntriesChanged:
case EMsvEntriesDeleted:
{
CMsvEntrySelection* entries =
static_cast<CMsvEntrySelection*>( aArg1 );
if ( ContainsMRMailBoxEntryL( *entries ) )
{
// Note: in case of entry deletion it is important that
// iMRMailBoxes array is refreshed only after evaluating
// ContainsMRMailBoxEntryL()
FindMRMailBoxesL();
iParentObserver.HandleSessionEventL( aEvent,
aArg1,
aArg2,
aArg3 );
}
break;
}
default:
{
// ignore other events
break;
}
}
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::ContainsMRMailBoxEntryL
// ----------------------------------------------------------------------------
//
TBool CMRUtilsMsvHelper::ContainsMRMailBoxEntryL(
const CMsvEntrySelection& aEntries ) const
{
TBool retVal( EFalse );
TInt count( iMRMailBoxes.Count() );
for ( TInt i( 0 ); i < count; ++i )
{
if ( aEntries.Find( iMRMailBoxes[i]->EntryId() ) != KErrNotFound )
{
retVal = ETrue;
break;
}
}
return retVal;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::FindMRMailBoxesL
// ----------------------------------------------------------------------------
//
void CMRUtilsMsvHelper::FindMRMailBoxesL()
{
EnsureSessionExistsL();
iMRMailBoxes.ResetAndDestroy();
// list also hidden (3rd party) accounts -> 2nd parameter == ETrue
CMsvEntrySelection* allMailBoxes =
MsvUiServiceUtilities::GetListOfAccountsL( *iSession, ETrue );
CleanupStack::PushL( allMailBoxes );
AddToListIfMRMailBoxesL( *allMailBoxes );
CleanupStack::PopAndDestroy( allMailBoxes );
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::AddToListIfMRMailBoxesL
// ----------------------------------------------------------------------------
//
TBool CMRUtilsMsvHelper::AddToListIfMRMailBoxesL(
const CMsvEntrySelection& aEntries )
{
TBool retVal( EFalse );
TInt count( aEntries.Count() );
for ( TInt i( 0 ); i < count; ++i )
{
TBool result( EFalse );
// don't care if individual mailboxes cause some problems
TRAP_IGNORE( result = AddToListIfMRMailBoxL( aEntries.At( i ) ) );
if ( result )
{ // retVal can only go from EFalse to ETrue, not other way
retVal = ETrue;
}
}
return retVal;
}
// ----------------------------------------------------------------------------
// CMRUtilsMsvHelper::AddToListIfMRMailBoxL
// ----------------------------------------------------------------------------
//
TBool CMRUtilsMsvHelper::AddToListIfMRMailBoxL( TMsvId aEntryId )
{
TBool retVal( EFalse );
EnsureSessionExistsL();
TMsvEntry entry;
TMsvId dummyService;
CMRMailBoxInfo* info( NULL );
TInt result = iSession->GetEntry( aEntryId, dummyService, entry );
if ( result == KErrNone &&
entry.iType == KUidMsvServiceEntry &&
IsMRCapableL( entry.iMtm ) )
{
EMailAddressL( entry ) ;
if ( MsvUiServiceUtilities::IsValidEmailAddressL( iEmailAddr ) )
{
info = CMRMailBoxInfo::NewL( entry.iDetails,
iEmailAddr,
entry.iMtm,
aEntryId );
CleanupStack::PushL( info );
iMRMailBoxes.AppendL( info ); // ownership transferred
retVal = ETrue;
CleanupStack::Pop( info );
}
}
return retVal;
}
// End of file