diff -r 000000000000 -r 8466d47a6819 ipsservices/ipssosplugin/src/ipsplgeventhandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ipsservices/ipssosplugin/src/ipsplgeventhandler.cpp	Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,1717 @@
+/*
+* Copyright (c) 2007 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:  This file implements class CIPSAccountInfo.
+*
+*/
+
+
+#include "emailtrace.h"
+#include "ipsplgheaders.h"
+
+const TInt KEventGranularity = 2;
+//<cmail>
+const TInt KMaxDriveUnitValue = 25;
+//</cmail>
+
+#ifdef _DEBUG
+_LIT( KIpsPlgEventHandlerPanic, "ArrError");
+#endif
+
+// ----------------------------------------------------------------------------
+// class CIPSAccountInfo
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+CIPSAccountInfo* CIPSAccountInfo::NewL(
+    const TDesC& aName, const TFSMailMsgId& aMBoxId )
+    {
+    FUNC_LOG;
+    CIPSAccountInfo* self = new(ELeave)CIPSAccountInfo( aMBoxId );
+    CleanupStack::PushL( self );
+    self->ConstructL( aName );
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIPSAccountInfo::ConstructL( const TDesC& aName )
+    {
+    FUNC_LOG;
+    iName = aName.AllocL();
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+CIPSAccountInfo::CIPSAccountInfo( const TFSMailMsgId& aMBoxId ) :
+    iMBoxId( aMBoxId )
+    {
+    FUNC_LOG;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+CIPSAccountInfo::~CIPSAccountInfo()
+    {
+    FUNC_LOG;
+    delete iName;
+    }
+
+// ----------------------------------------------------------------------------
+// class CIpsPlgEventHandler
+// ----------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+CIpsPlgEventHandler* CIpsPlgEventHandler::NewL(
+    CIpsPlgSosBasePlugin& aBasePlugin )
+    {
+    FUNC_LOG;
+    CIpsPlgEventHandler* self = new( ELeave ) CIpsPlgEventHandler(
+        aBasePlugin );
+    CleanupStack::PushL( self );
+    self->ConstructL( );
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+CIpsPlgEventHandler::~CIpsPlgEventHandler()
+    {
+    FUNC_LOG;
+    UnRegisterPropertyObserver( this );
+    iMBoxObservers.ResetAndDestroy();
+    iMBoxObservers.Close();
+    iIPSAccounts.ResetAndDestroy();
+    iIPSAccounts.Close();
+    if ( iCenRep )
+        {
+        iCenRep->NotifyCancelAll();
+        }
+    delete iCenRep;
+    iIPSSettingsObservers.ResetAndDestroy();
+    iIPSSettingsObservers.Close();
+    iPropertyObservers.Close();
+    delete iSettingsApi;
+    iImapFolderIds.Close();
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+CIpsPlgEventHandler::CIpsPlgEventHandler(
+    CIpsPlgSosBasePlugin& aBasePlugin )
+    :iBasePlugin( aBasePlugin ),
+    iMBoxObservers( KEventGranularity ),
+    iIPSAccounts( KEventGranularity ),
+    iIPSSettingsObservers( KEventGranularity ),
+    iIsConnected( EFalse ),
+    iPropertyObservers( KEventGranularity )
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+void CIpsPlgEventHandler::ConstructL( )
+    {
+    FUNC_LOG;
+    iCenRep = CRepository::NewL( KCRUidExtendedSettingsUid );
+    iPluginId = iBasePlugin.PluginId();
+    RegisterPropertyObserverL( this );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::CompleteConstructL( CMsvSession* aSession )
+    {
+    FUNC_LOG;
+    iSession = aSession;
+    iSettingsApi = CIpsSetDataApi::NewL( *iSession );
+
+    // this collects all folderids to array from mailboxes that
+    // have registered observers, this is need to do here because
+    // observers might be registered before calling complete construct
+    RArray<TMsvId> mboxes( KEventGranularity );
+    for ( TInt i = 0; i < iMBoxObservers.Count(); i++ )
+        {
+        TMsvId mboxId = iMBoxObservers[i]->iMBoxId.Id();
+        if ( mboxes.Find(mboxId) == KErrNotFound )
+            {
+            mboxes.Append( mboxId );
+            }
+        }
+
+    for ( TInt i = 0; i < mboxes.Count(); i++ )
+        {
+        CollectSubscribedFoldersL( mboxes[i] );
+        }
+    mboxes.Close();
+
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TInt CIpsPlgEventHandler::SetNewPropertyEvent(
+        TInt aMailbox, TInt aEvent, TInt aError )
+    {
+    FUNC_LOG;
+    TIpsPlgPropertyEvent pEvent(  aEvent, aMailbox ,
+            iBasePlugin.PluginId() ,aError );
+    TInt error = SetProperty( pEvent );
+    return error;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TInt CIpsPlgEventHandler::SetProperty( TIpsPlgPropertyEvent aEvent )
+    {
+    FUNC_LOG;
+    TInt error = RProperty::Define(
+            KIpsPlgPropertyCatUid,
+        KIPSSosEventPropertyKey, RProperty::EByteArray,
+        KAllowAllPolicy,
+        KAllowWriteDeviceDataPolicy );
+
+    iPropertyBuf = aEvent;
+
+    // if definition was success
+    if ( error == KErrNone ||
+         error == KErrAlreadyExists ||
+         error == KErrPermissionDenied )
+        {
+        error = RProperty::Set(
+                KIpsPlgPropertyCatUid,
+                KIPSSosEventPropertyKey, iPropertyBuf );
+
+        }
+    return error;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TInt CIpsPlgEventHandler::RegisterPropertyObserverL(
+        MIpsPlgPropertyObserver* aObserver )
+    {
+    FUNC_LOG;
+    if ( !aObserver )
+        {
+        User::Leave( KErrArgument );
+        }
+
+    if ( !iPropertyWatcher )
+        {
+        iPropertyWatcher = CIpsPlgPropertyWatcher::NewL(
+                CActive::EPriorityIdle, *this );
+        }
+
+    return iPropertyObservers.Append( aObserver );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::UnRegisterPropertyObserver(
+        MIpsPlgPropertyObserver* aObserver )
+    {
+    FUNC_LOG;
+    TInt index = iPropertyObservers.Find( aObserver );
+
+    if ( index != KErrNotFound )
+        {
+        iPropertyObservers.Remove( index );
+        }
+
+    if ( iPropertyObservers.Count() == 0 )
+        {
+        delete iPropertyWatcher;
+        iPropertyWatcher = NULL;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::NotifyPropertyEventL(
+        TIpsPlgPropertyEvent aEvent )
+    {
+    FUNC_LOG;
+    TBool doNotify = ETrue;
+    switch ( aEvent.iEvent )
+        {
+        case KIpsSosEmailSyncStarted:
+            SignalStartSyncL( TFSMailMsgId( aEvent.iPluginId,
+                    aEvent.iMailbox ) );
+            break;
+        case KIpsSosEmailSyncCompleted:
+            {
+            SignalSyncCompletedL( TFSMailMsgId( aEvent.iPluginId,
+                    aEvent.iMailbox ), aEvent.iError );
+                }
+            break;
+        default:
+            break;
+        }
+
+    for ( TInt i = 0; doNotify && i < iPropertyObservers.Count(); i++ )
+        {
+        TRAP_IGNORE( iPropertyObservers[i]->HandlePropertyEventL(
+                aEvent.iEvent,  aEvent.iMailbox,
+                aEvent.iPluginId, aEvent.iError ) );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleSessionEventL(
+    MMsvSessionObserver::TMsvSessionEvent aEvent,
+    TAny* aArg1,
+    TAny* aArg2,
+    TAny* aArg3)
+    {
+    FUNC_LOG;
+    if ( aEvent == MMsvSessionObserver::EMsvServerReady )
+        {
+        iBasePlugin.CompleteConstructL();
+        IPSAccountsL();
+        return;
+        }
+    if ( !iPluginObserver && iMBoxObservers.Count()==0 )
+        {
+        //if no observer we can't relay these events.
+        return;
+        }
+    //<cmail>
+    if ( iMBoxObservers.Count() == 0 && aArg2 &&
+        (*(TMsvId*) (aArg2)) != KMsvRootIndexEntryIdValue &&
+        aEvent != EMsvMediaChanged )
+        {
+        // event is related to messages / folders, can return
+        // because no mailbox observers found
+        return;
+        }
+    //</cmail>
+    
+    switch( aEvent )
+        {
+        case EMsvEntriesCreated:
+            HandleEntriesCreatedL( aArg1, aArg2, aArg3 );
+            break;
+        case EMsvEntriesDeleted:
+            HandleEntriesDeletedL( aArg1, aArg2, aArg3 );
+            break;
+        case EMsvEntriesChanged:
+            HandleEntriesChangedL( aArg1, aArg2, aArg3 );
+            break;
+        case EMsvEntriesMoved:
+            HandleEntriesMovedL( aArg1, aArg2, aArg3 );
+            break;
+        case EMsvServerTerminated:
+            iBasePlugin.SessionTerminated();
+            iSession = NULL;
+            break;
+        case EMsvCloseSession:
+            break;
+        case EMsvGeneralError:
+            break;
+        //<cmail>    
+        case EMsvMediaChanged:
+            HandleMediaChangedL( aArg1, aArg2, aArg3 );
+            break;
+        //</cmail>
+        default:
+            //we don't care about unhandled events
+            break;
+        };
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::AddPluginObserverL(
+    MFSMailEventObserver* aObserver )
+    {
+    FUNC_LOG;
+    // there can be several plugin observers??
+    iPluginObserver = aObserver;
+    }
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::RemovePluginObserver(
+    MFSMailEventObserver* /*aObserver*/ )
+    {
+    FUNC_LOG;
+    iPluginObserver = NULL;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SubscribeMailboxEventsL(
+    const TFSMailMsgId& aMailboxId,
+    MFSMailEventObserver& aObserver,
+    TUint32 aKey )
+    {
+    FUNC_LOG;
+    CMBoxEventObserver* observer = new(ELeave) CMBoxEventObserver( aObserver, aMailboxId );
+    CleanupStack::PushL( observer );
+    iMBoxObservers.AppendL( observer );
+    CleanupStack::Pop( observer );
+    AppendSettingsObserverL( aMailboxId, aKey );
+    //at the moment we won't support syncstate events for IMAP alwaysonline.
+    //because of imap idle. we can't extract usefull syncstate changes when it is in use.
+   /* if ( iBasePlugin.MtmId().iUid != KSenduiMtmImap4UidValue )
+        {
+        AppendSyncStateObserverL( aMailboxId );
+        }*/
+    if( aMailboxId.PluginId() == KIpsPlgImap4PluginUid )
+        {
+        CollectSubscribedFoldersL( aMailboxId.Id() );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::UnsubscribeMailboxEvents(
+    const TFSMailMsgId& aMailboxId,
+    MFSMailEventObserver& aObserver )
+    {
+    FUNC_LOG;
+    TInt count = iMBoxObservers.Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        if( &iMBoxObservers[i]->iObserver == &aObserver )
+            {
+            RemoveSettingsObserver( aMailboxId );
+            delete iMBoxObservers[i];
+            iMBoxObservers.Remove(i);
+            break;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+TBool CIpsPlgEventHandler::IsEventFromIpsSourceL( TAny* aArg1,
+                                                  TUid& aSourceType,
+                                                  TMsvEntry& aEntry )
+    {
+    FUNC_LOG;
+    const CMsvEntrySelection* selection =
+        static_cast<CMsvEntrySelection*>( aArg1 );
+
+    TMsvId dummy( KMsvNullIndexEntryIdValue );
+    TMsvId entryId( KMsvNullIndexEntryIdValue );
+    if ( selection->Count() == 0)
+        {
+        User::Leave( KErrArgument );
+        }
+
+    if( !iSession )
+        {
+        User::Leave( KErrNotReady );
+        }
+
+    entryId = selection->At(0);
+    User::LeaveIfError( iSession->GetEntry( entryId, dummy, aEntry ) );
+
+    //we set the source type regardless is it IPS ( imap/pop )
+    aSourceType = aEntry.iType;
+
+
+    TBool ret = ETrue;
+    //we're interested only in events from own mtm type
+    //or ny messages in smtp folder
+    if ( aEntry.iMtm.iUid != iBasePlugin.MtmId().iUid )
+        {
+        //when creating a mailbox, we come here only once,
+        //so this is reliable way to see mailbox creation.
+        ret = EFalse;
+        }
+    else if ( aEntry.iType.iUid < KUidMsvRootEntryValue ||
+             aEntry.iType.iUid > KUidMsvAttachmentEntryValue )
+         {
+         ret = EFalse;
+         }
+
+    if ( !ret && aEntry.iMtm.iUid == KSenduiMtmSmtpUidValue )
+        {
+        ret = ETrue;
+        }
+
+
+    return ret;
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+inline TFSMailMsgId CIpsPlgEventHandler::SymId2FsId(
+    TMsvId aId, TUint aMtmUid )
+    {
+    FUNC_LOG;
+    TFSMailMsgId id;
+    id.SetId( aId );
+    if ( aMtmUid == KSenduiMtmImap4UidValue )
+        {
+        id.SetPluginId( KIpsPlgImap4PluginUid );
+        }
+    else if ( aMtmUid == KSenduiMtmPop3UidValue )
+        {
+        id.SetPluginId( KIpsPlgPop3PluginUid );
+        }
+    else if ( aMtmUid == KSenduiMtmSmtpUidValue )
+        {
+        // set plugin id to this plugin
+        id.SetPluginId( TUid::Uid(iPluginId) );
+        }
+    return id;
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+inline TFSMailMsgId CIpsPlgEventHandler::SymId2FsId(
+    const TMsvEntry& aEntry )
+    {
+    FUNC_LOG;
+    return SymId2FsId( aEntry.Id(), aEntry.iMtm.iUid );
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+inline void CIpsPlgEventHandler::FillFSMessageArray(
+    RArray<TFSMailMsgId>& aFSArray,
+    const CMsvEntrySelection* aSelection,
+    TUint aMtmUid )
+    {
+    FUNC_LOG;
+    // function should used only with empty (new) arrays
+    __ASSERT_DEBUG( ( aFSArray.Count() == 0 ),
+        User::Panic( KIpsPlgEventHandlerPanic, KErrGeneral ) );
+
+    for ( TInt i = 0; i < aSelection->Count(); i++ )
+        {
+        aFSArray.Append( SymId2FsId(aSelection->At(i), aMtmUid) );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SendDelayedEventL(
+    TFSMailEvent aEvent,
+    TFSMailMsgId aMailbox,
+    TAny* aArg1,
+    TAny* aArg2,
+    TAny* aArg3 )
+    {
+    FUNC_LOG;
+    TIpsPlgEvent event;
+    event.iAccountId = aMailbox;
+    event.iEvent = aEvent;
+    event.iArg1 = aArg1;
+    event.iArg2 = aArg2;
+    event.iArg3 = aArg3;
+
+    RPointerArray<MFSMailEventObserver> observers;
+    CleanupClosePushL( observers );
+
+    if( aEvent == TFSEventNewMailbox ||
+        aEvent == TFSEventMailboxRenamed ||
+        aEvent == TFSEventMailboxDeleted )
+        {
+        //<cmail>
+        if( iPluginObserver )
+            {
+            // Could been deleted within observer itself
+            observers.AppendL( iPluginObserver );
+            }
+        //</cmail>
+        }
+    else
+        {
+        //other events go to mailbox specific observers
+        MailboxObserversL( aMailbox, observers );
+        }
+    for( TInt i = 0; i < observers.Count(); ++i )
+        {
+        // ignore leave so that other observers get event even if
+        // one leaves
+        TRAP_IGNORE(observers[i]->EventL(
+            event.iEvent,
+            event.iAccountId,
+            event.iArg1,
+            event.iArg2,
+            event.iArg3 ));
+        }
+    CleanupStack::PopAndDestroy( &observers );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::IPSAccountsL()
+    {
+    FUNC_LOG;
+    if( !iSession )
+        {
+        User::Leave( KErrNotReady );
+        }
+    CMsvEntry* root = iSession->GetEntryL( KMsvRootIndexEntryIdValue );
+    CleanupStack::PushL( root );
+
+    CMsvEntrySelection* pop = root->ChildrenWithMtmL( KSenduiMtmPop3Uid );
+    CleanupStack::PushL( pop );
+
+    CMsvEntrySelection* imap = root->ChildrenWithMtmL( KSenduiMtmImap4Uid );
+    CleanupStack::PushL( imap );
+
+    TInt count = pop->Count();
+    TMsvEntry tEntry;
+    TMsvId service;
+    for ( TInt i=0; i<count; i++ )
+        {
+        iSession->GetEntry( pop->At(i), service, tEntry );
+        //<cmail>
+        if( !AccountExistsL( tEntry ) )
+            {
+            iIPSAccounts.AppendL( CIPSAccountInfo::NewL( 
+                tEntry.iDetails, 
+                SymId2FsId( tEntry ) ) );    
+            }
+        //</cmail>
+        }
+        
+    count = imap->Count();
+    for ( TInt i=0; i<count; i++ )
+        {
+        iSession->GetEntry( imap->At(i), service, tEntry );
+        //<cmail>
+        if( !AccountExistsL( tEntry ) )
+            {  
+            iIPSAccounts.AppendL( CIPSAccountInfo::NewL( 
+                tEntry.iDetails, 
+                SymId2FsId( tEntry ) ) );
+            }
+        //</cmail>
+        }        
+    
+    CleanupStack::PopAndDestroy( 3, root );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleEntriesCreatedL(
+    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/ )
+    {
+    FUNC_LOG;
+    TUid type;
+    TMsvEntry tNew;
+
+    if( IsEventFromIpsSourceL( aArg1, type, tNew ) )
+        {
+        TAny* arg1=NULL;
+        TAny* arg2=NULL;
+        TAny* arg3=NULL;
+
+        TFSMailEvent event;
+        TFSMailMsgId mbox;
+
+        if ( type == KUidMsvServiceEntry )
+            {
+            event = TFSEventNewMailbox;
+
+            mbox = SymId2FsId( tNew );
+
+            if( AccountExistsL( tNew ) )
+                {
+                //this is a duplicate event. Ignoring...
+                return;
+                }
+
+            iIPSAccounts.AppendL( CIPSAccountInfo::NewL(
+                tNew.iDetails,
+                mbox ) );
+            SendDelayedEventL( event, mbox,
+                arg1, arg2 , arg3 );
+            }
+        
+        // discard any new mail events if message is marked as deleted in imap
+        const TMsvEmailEntry& emlEntry(tNew);
+        TBool isMarkedAsDeleted = EFalse;
+        if ( mbox.PluginId() == KIpsPlgImap4PluginUid
+                && (EDisconnectedDeleteOperation == emlEntry.DisconnectedOperation()
+                || emlEntry.DeletedIMAP4Flag()) )
+            {
+            isMarkedAsDeleted = ETrue;
+            }
+        
+        
+        if ( type == KUidMsvMessageEntry && !isMarkedAsDeleted )
+            {
+            TMsvId* parent = static_cast<TMsvId*>(aArg2);
+            event = TFSEventNewMail;
+            TFSMailMsgId mbox;
+
+            if ( tNew.iServiceId == KMsvLocalServiceIndexEntryIdValue
+                || tNew.Parent() == KMsvDraftEntryIdValue )
+                {
+                TMsvEntry srvEntry;
+                TMsvId dummy;
+                if( !iSession )
+                    {
+                    User::Leave( KErrNotReady );
+                    }
+                iSession->GetEntry( tNew.iServiceId, dummy, srvEntry );
+                iSession->GetEntry( srvEntry.iRelatedId, dummy, srvEntry );
+                mbox = SymId2FsId( srvEntry );
+                }
+            else
+                {
+                mbox = SymId2FsId( tNew.iServiceId , tNew.iMtm.iUid );
+                // start automatic sync
+                if ( iBasePlugin.IsUnderUiProcess() &&
+                        iBasePlugin.PluginId() == KIpsPlgImap4PluginUidValue )
+                    {
+                    iBasePlugin.PopulateNewMailL(
+                            mbox, tNew.Id(), tNew.Parent() );
+                    }
+                }
+
+            // set entries array pointer
+            RArray<TFSMailMsgId> array(KEventGranularity);
+            CleanupClosePushL( array );
+
+            FillFSMessageArray(
+                array,
+                static_cast<const CMsvEntrySelection*>(aArg1),
+                tNew.iMtm.iUid );
+            arg1 = static_cast<TAny*>(&array);
+
+            // set parent pointer
+            parent = static_cast<TMsvId*>(aArg2);
+            TFSMailMsgId tfsid( iPluginId, *parent);
+            arg2 = static_cast<TAny*>(&tfsid);
+
+            SendDelayedEventL( event, mbox,
+                arg1, arg2 , arg3 );
+            CleanupStack::PopAndDestroy( &array );
+            }
+        else if ( type == KUidMsvFolderEntry )
+            {
+            event = TFSEventNewFolder;
+            mbox = SymId2FsId( tNew.iServiceId, tNew.iMtm.iUid );
+
+            // set entries array pointer
+            RArray<TFSMailMsgId> array(1);
+            CleanupClosePushL( array );
+            array.Append( SymId2FsId( tNew ) );
+            arg1 = &array;
+
+            // set parent pointer
+            TMsvId* parent = static_cast<TMsvId*>(aArg2);
+            TFSMailMsgId tfsid( iPluginId, *parent);
+            arg2 = static_cast<TAny*>(&tfsid);
+
+            SendDelayedEventL( event, mbox,
+                arg1, arg2 , arg3 );
+
+            CleanupStack::PopAndDestroy( &array );
+
+            if( tNew.iMtm.iUid == KSenduiMtmImap4UidValue )
+                {
+                SetFolderIdToArrayL( tNew.Id() );
+                }
+            }
+        else//attachment
+            {
+            return;
+            //do we need to handle this? maybe....
+            }
+
+        // set null to prevent later usage in framework side
+        // causes kern exec 3 panic...
+        arg1 = arg2 = arg3 = NULL;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleEntriesMovedL(
+    TAny* aArg1, TAny* aArg2, TAny* aArg3 )
+    {
+    FUNC_LOG;
+    TUid type;
+    TMsvEntry tMoved;
+    if( IsEventFromIpsSourceL( aArg1, type, tMoved ) )
+        {
+        //sent to draft can cause problems
+        TAny* arg1=NULL;
+        TAny* arg2=NULL;
+        TAny* arg3=NULL;
+
+        TFSMailEvent event( TFSMailboxUnavailable );
+
+        RArray<TFSMailMsgId> array(KEventGranularity);
+        CleanupClosePushL( array );
+        FillFSMessageArray(
+            array,
+            static_cast<const CMsvEntrySelection*>(aArg1),
+            tMoved.iMtm.iUid );
+
+        arg1 = &array;
+        TFSMailMsgId tempId1 = TFSMailMsgId( iPluginId, *(static_cast<TMsvId*>(aArg2) ) ); //target
+        arg2 = &tempId1;
+        TFSMailMsgId tempId2 = TFSMailMsgId( iPluginId, *(static_cast<TMsvId*>(aArg3)) ); //source
+        arg3 = &tempId2;
+
+        if( tMoved.iType == KUidMsvMessageEntry )
+            {
+            event = TFSEventMailMoved;
+            }
+        else if( tMoved.iType == KUidMsvFolderEntry )
+            {
+            event = TFSEventFoldersMoved;
+            }
+
+        TFSMailMsgId mbox;
+        // solve mailbox.
+        if ( tMoved.iMtm.iUid == KSenduiMtmSmtpUidValue )
+            {
+            TMsvEntry serv;
+            TMsvId service;
+            iSession->GetEntry( tMoved.iServiceId, service, serv );
+            //get correct imap/pop service to tEntry
+            iSession->GetEntry( serv.iRelatedId, service, serv );
+            mbox = SymId2FsId( serv.iServiceId, serv.iMtm.iUid );
+            }
+        else
+            {
+            mbox = SymId2FsId( tMoved.iServiceId, tMoved.iMtm.iUid );
+            }
+
+        SendDelayedEventL(
+            event,
+            mbox,
+            arg1,
+            arg2,
+            arg3 );
+
+        CleanupStack::PopAndDestroy( &array );
+        // set null to prevent later usage in framework side
+        // causes kern exec 3 panic...
+        arg1 = arg2 = arg3 = NULL;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleEntriesDeletedL(
+    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/ )
+    {
+    FUNC_LOG;
+
+    if ( !aArg1 || !aArg2 )
+        {
+        // sometimes we get null pointers from symbian api
+        return;
+        }
+
+    TAny* arg1=NULL;
+    TAny* arg2=NULL;
+    TAny* arg3=NULL;
+
+    TFSMailEvent event( TFSMailboxUnavailable );
+
+    //parent must be root for it to be mailbox
+    if( (*(TMsvId*) (aArg2)) == KMsvRootIndexEntryIdValue )
+        {
+        CMsvEntrySelection* sel = static_cast<CMsvEntrySelection*>(aArg1);
+        TFSMailMsgId id;
+        TBool found = EFalse;
+        TInt count = iIPSAccounts.Count();
+        TInt selCount = sel->Count();
+
+        for(TInt i=count-1; i>=0; i--)
+            {
+            TMsvId mboxId = iIPSAccounts[i]->iMBoxId.Id();
+            for (TInt j = 0; j < selCount; j++ )
+                {
+                TMsvId deletedId = sel->At(j);
+                if ( deletedId == mboxId)
+                    {
+                    iIPSAccounts[i];
+                    id.SetId( deletedId );
+                    id.SetPluginId( iIPSAccounts[i]->iMBoxId.PluginId() );
+                    delete iIPSAccounts[i];
+                    iIPSAccounts.Remove(i);
+                    found = ETrue;
+                    break;
+                    }
+                }
+            }
+
+        if(!found)
+            {
+            //was some other service, ignore.
+            return;
+            }
+
+        //check is the id of the deleted entry in our account list.
+
+        event = TFSEventMailboxDeleted;
+        SendDelayedEventL(
+            event,
+            id,
+            arg1,
+            arg2,
+            arg3 );
+        }
+    else
+        {
+        //aArg2 is a service OR a folder
+        TMsvEntry tEntry;
+        TMsvId service;
+        TBool isFolderId( EFalse );
+        if( !iSession )
+            {
+            User::Leave( KErrNotReady );
+            }
+        iSession->GetEntry( (*(TMsvId*) (aArg2)), service, tEntry );
+
+        if( tEntry.iMtm.iUid == iBasePlugin.MtmId().iUid )
+            {
+            CMsvEntrySelection* sel = static_cast<CMsvEntrySelection*>(aArg1);
+	        TMsvId deletedId( KMsvNullIndexEntryIdValue );
+	        TInt count = sel->Count();
+
+    		if( count )
+	            {
+	            // In case we get several id's, ignore others than
+	            // last one which is the actual message/root folder id.
+	            deletedId = sel->At(count-1);
+	            }
+
+            // message in remote folder (inbox)
+            TFSMailMsgId mbox(iPluginId, tEntry.iServiceId );
+            RArray<TFSMailMsgId> array( KEventGranularity );
+            CleanupClosePushL( array );
+            TFSMailMsgId parentId( iPluginId, tEntry.Id() );
+
+            if ( tEntry.iMtm.iUid == KSenduiMtmImap4UidValue )
+                {
+                isFolderId = MatchFolderIdFound( deletedId );
+                }
+            if( !isFolderId )
+                {
+                FindCorrectDeletedEntryAndParentL(
+                    tEntry, *sel, parentId, array );
+
+                if ( array.Count() > 0 )
+                    {
+                    arg1 = &array;
+                    arg2 = &parentId;
+
+                    event = TFSEventMailDeleted;
+                    SendDelayedEventL(
+                        event,
+                        mbox,
+                        arg1,
+                        arg2,
+                        arg3 );
+                    }
+                }
+            else
+                {
+                array.Append( SymId2FsId(deletedId, tEntry.iMtm.iUid) );
+                arg1 = &array;
+                arg2 = &parentId;
+
+                event = TFSEventFoldersDeleted;
+                SendDelayedEventL(
+                    event,
+                    mbox,
+                    arg1,
+                    arg2,
+                    arg3 );
+                }
+
+            CleanupStack::PopAndDestroy( &array );
+            }
+        else if ( tEntry.iMtm.iUid == KSenduiMtmSmtpUidValue )
+            {
+            // seems that case when deleding from draft, symbian
+            // sends event that contains some child part's id of
+            // correct deleted mail. So append parents id to array
+            TFSMailMsgId msg;
+            msg.SetId( tEntry.Id() );
+            TFSMailMsgId parent;
+            parent.SetId( tEntry.Parent() );
+            if( !iSession )
+                {
+                User::Leave( KErrNotReady );
+                }
+            //re-load smtp service to tEntry
+            iSession->GetEntry( tEntry.iServiceId, service, tEntry );
+            //get correct imap/pop service to tEntry
+            iSession->GetEntry( tEntry.iRelatedId, service, tEntry );
+
+            TFSMailMsgId mbox;
+            mbox.SetId( tEntry.Id() );
+
+            // set plugin id to msg, parent and mbox
+            if ( tEntry.iMtm.iUid == KSenduiMtmImap4UidValue )
+        		{
+        		parent.SetPluginId( KIpsPlgImap4PluginUid );
+        		msg.SetPluginId( KIpsPlgImap4PluginUid );
+        		mbox.SetPluginId( KIpsPlgImap4PluginUid );
+        		}
+    		else if ( tEntry.iMtm.iUid == KSenduiMtmPop3UidValue )
+        		{
+        		parent.SetPluginId( KIpsPlgPop3PluginUid );
+        		msg.SetPluginId( KIpsPlgPop3PluginUid );
+        		mbox.SetPluginId( KIpsPlgPop3PluginUid );
+        		}
+            else
+                {
+                // Should be panic at this point?
+                return;
+                }
+
+            RArray<TFSMailMsgId> array(1);
+            CleanupClosePushL( array );
+            array.Append( msg );
+            arg1 = &array;
+            arg2 = &parent;
+            event = TFSEventMailDeleted;
+            SendDelayedEventL(
+                event,
+                mbox,
+                arg1,
+                arg2,
+                arg3 );
+            CleanupStack::PopAndDestroy( &array );
+            }
+        else
+            {
+            //deletion happened under some other service that IPS.
+            return;
+            }
+        }
+    // set null to prevent later usage in framework side
+    // causes kern exec 3 panic...
+    arg1 = arg2 = arg3 = NULL;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleEntriesChangedL(
+    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/ )
+    {
+    FUNC_LOG;
+    TAny* arg1=NULL;
+    TAny* arg2=NULL;
+    TAny* arg3=NULL;
+
+    TUid uId;
+    TMsvEntry tChanged;
+    if ( !IsEventFromIpsSourceL( aArg1, uId, tChanged ) )
+        {
+        return;
+        }
+    else if ( tChanged.iMtm.iUid == KSenduiMtmSmtpUidValue )
+        {
+        // do not send entry changed events from draft messages
+        // mess up draft email
+        return;
+        }
+
+    TFSMailEvent event = static_cast<TFSMailEvent>( KErrNotFound );
+
+    RArray<TFSMailMsgId> array(1);
+    CleanupClosePushL( array );
+
+    if ( tChanged.iType == KUidMsvMessageEntry )
+        {
+        TMsvEmailEntry emailEntry(tChanged);
+        if( emailEntry.DeletedIMAP4Flag() /*|| tChanged.Deleted()*/ )
+            {
+            event = TFSEventMailDeleted;
+            }
+        else
+            {
+            event = TFSEventMailChanged;
+            }
+
+        // message entry
+        array.Append( SymId2FsId( tChanged )  );
+        arg1 = &array;
+
+        // parent entry
+        TFSMailMsgId id = SymId2FsId( *(static_cast<TMsvId*>(aArg2)), tChanged.iMtm.iUid );
+        arg2 = &id;
+
+        }
+    else if ( tChanged.iType == KUidMsvFolderEntry )
+        {
+        event = TFSEventFolderChanged;
+
+        array.Append( SymId2FsId( tChanged ) );
+        arg1 = &array;
+
+        TFSMailMsgId id = SymId2FsId( *(static_cast<TMsvId*>(aArg2)), tChanged.iMtm.iUid );
+        arg2 = &id;
+
+        if ( tChanged.iMtm.iUid == KSenduiMtmImap4UidValue )
+            {
+            TMsvEmailEntry eml( tChanged );
+            TInt index = iImapFolderIds.Find(tChanged.Id());
+            if ( eml.LocalSubscription() && index == KErrNotFound )
+                {
+                iImapFolderIds.Append( tChanged.Id() );
+                }
+            else if ( !eml.LocalSubscription() && index != KErrNotFound )
+                {
+                iImapFolderIds.Remove( index );
+                }
+            }
+
+        }
+    else if( IsConnectionChangeL( aArg1, aArg2 ) )
+        {
+        if ( iIsConnected )
+            {
+            event = TFSEventMailboxOnline;
+            }
+        else
+            {
+            event = TFSEventMailboxOffline;
+            }
+        }
+    else if( IsAccountNameChangeL( aArg1, aArg2 ) )
+        {
+        event = TFSEventMailboxRenamed;
+        }
+
+    // send event only if we found correct one
+    if ( event != KErrNotFound )
+        {
+        TFSMailMsgId mbox;
+        // solve mailbox.
+        if ( tChanged.iMtm.iUid == KSenduiMtmSmtpUidValue )
+            {
+            TMsvEntry serv;
+            TMsvId service;
+            if( !iSession )
+                {
+                User::Leave( KErrNotReady );
+                }
+            iSession->GetEntry( tChanged.iServiceId, service, serv );
+            //get correct imap/pop service to tEntry
+            iSession->GetEntry( serv.iRelatedId, service, serv );
+            mbox = SymId2FsId( serv.iServiceId, serv.iMtm.iUid );
+            }
+        else
+            {
+            mbox = SymId2FsId( tChanged.iServiceId, tChanged.iMtm.iUid );
+            }
+
+        SendDelayedEventL( event,
+            mbox, arg1, arg2, arg3 );
+        }
+    CleanupStack::PopAndDestroy( &array );
+    // set null to prevent later usage in framework side
+    // causes kern exec 3 panic...
+    arg1 = arg2 = arg3 = NULL;
+    }
+//<cmail>
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandleMediaChangedL( 
+    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/ )
+    {
+    TAny* arg1=NULL;
+    TAny* arg2=NULL;
+    TAny* arg3=NULL;    
+    TMsvId service;
+    TMsvEntry tChanged;
+    TFSMailMsgId mbox;
+    TFSMailEvent event( TFSEventMailboxDeleted );
+    TInt startPoint(iIPSAccounts.Count()-1);
+    TInt from(*(TInt*) (aArg1));
+    TInt to(*(TInt*) (aArg2));
+
+    if ( !aArg1 || !aArg2 || 
+         from>KMaxDriveUnitValue || to>KMaxDriveUnitValue )
+        {
+        // Possibly duplicate event 
+        // or some other disinformation
+        return; 
+        }
+    if( !iSession )
+        {
+        User::Leave( KErrNotReady );
+        }
+
+    CMsvEntry* cEntry = iSession->GetEntryL( KMsvRootIndexEntryId );
+    CleanupStack::PushL( cEntry );
+    
+    CMsvEntrySelection* children = cEntry->ChildrenWithMtmL( MtmId() );
+    CleanupStack::PushL( children );
+        
+    for( TInt accIndex(startPoint); accIndex>=0; accIndex-- )
+        {
+        // Remove all mailboxes, also the ones possibly added to 
+        // array from current store to avoid duplicate boxes
+        mbox.SetId( iIPSAccounts[accIndex]->iMBoxId.Id() );
+        mbox.SetPluginId( iIPSAccounts[accIndex]->iMBoxId.PluginId() );
+        iIPSAccounts.Remove(accIndex);
+        SendDelayedEventL( event, mbox, arg1, arg2, arg3 );
+        }
+    for( TInt chdIndex(0); chdIndex<children->Count(); chdIndex++ )
+        {
+        // With clear table send mailboxes in current store
+        // to observers to complete full update
+        iSession->GetEntry( children->At(chdIndex), service, tChanged );
+        mbox = SymId2FsId( tChanged );
+        event = TFSEventNewMailbox;
+        SendDelayedEventL( event, mbox, arg1, arg2, arg3 );
+        }
+
+    CleanupStack::PopAndDestroy( 2 );
+    // set null to prevent later usage in framework side
+    // causes kern exec 3 panic...
+    arg1 = arg2 = arg3 = NULL;
+    }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+TUid CIpsPlgEventHandler::MtmId() const
+    {
+    TUid ret = KSenduiMtmImap4Uid;
+    if ( iBasePlugin.MtmId().iUid == KIpsPlgPop3PluginUidValue )
+        {
+        ret = KSenduiMtmPop3Uid;
+        }
+    return ret;
+    }
+//</cmail>
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------    
+TBool CIpsPlgEventHandler::IsConnectionChangeL( TAny* aArg1, TAny* aArg2 )
+    {
+    FUNC_LOG;
+    TMsvId parent = (*(TMsvId*) (aArg2));
+
+    //we check that parent is the root. if not, it cannot be a
+    //event from service, thus can't be from connection change..
+    if ( parent == KMsvRootIndexEntryId )
+        {
+        const CMsvEntrySelection* selection =
+            static_cast<CMsvEntrySelection*>( aArg1 );
+
+        TMsvEntry tEntry;
+        TMsvId service;
+        if( !iSession )
+            {
+            User::Leave( KErrNotReady );
+            }
+        if ( selection->Count() )
+            {
+            iSession->GetEntry( selection->At(0), service, tEntry );
+            }
+
+        if ( tEntry.Connected() == iIsConnected )
+            {
+            return EFalse;
+            }
+        else
+            {
+            //state has changed, update iIsConnected accordingly.
+            iIsConnected = tEntry.Connected();
+            return ETrue;
+            }
+        }
+
+    return EFalse;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::MailboxObserversL(
+    TFSMailMsgId aMailbox,
+    RPointerArray<MFSMailEventObserver>& aObservers )
+    {
+    FUNC_LOG;
+    TInt count = iMBoxObservers.Count();
+    for( TInt i=0; i<count; i++ )
+        {
+          CMBoxEventObserver* observer = iMBoxObservers[i];
+          if ( observer && observer->iMBoxId == aMailbox )
+            {
+            aObservers.AppendL( &iMBoxObservers[i]->iObserver );
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TBool CIpsPlgEventHandler::IsAccountNameChangeL( TAny* aArg1, TAny* aArg2 )
+    {
+    FUNC_LOG;
+    TMsvId parent = (*(TMsvId*) (aArg2));
+
+    TBool ret = EFalse;
+
+    //we check that parent is the root. if not, it cannot be a
+    //event from service, thus can't be from account name change
+    if ( parent == KMsvRootIndexEntryId )
+        {
+        const CMsvEntrySelection* selection =
+            static_cast<CMsvEntrySelection*>( aArg1 );
+
+        TMsvEntry tEntry;
+        TMsvId service;
+        if( !iSession )
+            {
+            User::Leave( KErrNotReady );
+            }
+        if ( selection->Count() )
+            {
+            iSession->GetEntry( selection->At(0), service, tEntry );
+            }
+
+        TInt count = iIPSAccounts.Count();
+        for( TInt i=0; i<count; i++ )
+            {
+            if( iIPSAccounts[i]->iMBoxId.Id() == tEntry.Id() )
+                {
+                if( iIPSAccounts[i]->iName->CompareC( tEntry.iDetails ) != 0 )
+                    {
+                    //account has been renamed
+                    delete iIPSAccounts[i]->iName;
+                    iIPSAccounts[i]->iName=NULL;
+                    iIPSAccounts[i]->iName = tEntry.iDetails.AllocL();
+                    ret = ETrue;
+                    break;
+                    }
+                }
+            }
+        }
+
+    return ret;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::AppendSettingsObserverL(
+    TFSMailMsgId aAccount,
+    TUint32 aSettingKey )
+    {
+    FUNC_LOG;
+    // recycle setting observers
+    TInt find = KErrNotFound;
+    for ( TInt i = 0; i < iIPSSettingsObservers.Count(); i++ )
+        {
+        if ( iIPSSettingsObservers[i]->MailboxId() == aAccount )
+            {
+            find = i;
+            break;
+            }
+        }
+
+    RPointerArray<MFSMailEventObserver> observers;
+    MailboxObserversL( aAccount, observers );
+
+    if ( find != KErrNotFound )
+        {
+        iIPSSettingsObservers[find]->SetKeyAndActivateL( aSettingKey, observers );
+        }
+    else
+        {
+        CIpsPlgSettingsObserver* obs =
+            CIpsPlgSettingsObserver::NewL( aAccount, *iCenRep, *this );
+        obs->SetKeyAndActivateL( aSettingKey, observers );
+        iIPSSettingsObservers.AppendL( obs );
+        }
+    observers.Close();
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::RemoveSettingsObserver( TFSMailMsgId aMailboxId )
+    {
+    FUNC_LOG;
+    TInt count = iIPSSettingsObservers.Count();
+    for( TInt i=0; i < count; i++ )
+        {
+        if( iIPSSettingsObservers[i]->MailboxId() == aMailboxId )
+            {
+            iIPSSettingsObservers[i]->UnActivate();
+            break;
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+MFSMailEventObserver* CIpsPlgEventHandler::MailboxObserverL(
+    TFSMailMsgId aMailbox )
+    {
+    FUNC_LOG;
+    TInt count = iMBoxObservers.Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        if ( iMBoxObservers[i]->iMBoxId == aMailbox )
+            {
+            return &iMBoxObservers[i]->iObserver;
+            }
+        }
+    return NULL;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TBool CIpsPlgEventHandler::AccountExistsL( const TMsvEntry& aEntry )
+    {
+    FUNC_LOG;
+    if ( !(aEntry.iMtm.iUid == KSenduiMtmImap4UidValue
+        || aEntry.iMtm.iUid == KSenduiMtmPop3UidValue) )
+        {
+        // check only imap and pop
+        return ETrue;
+        }
+
+    TInt count = iIPSAccounts.Count();
+
+    for( TInt i=0; i<count; i++ )
+        {
+        TInt a = aEntry.Id();
+        TInt b = iIPSAccounts[i]->iMBoxId.Id();
+
+        if( a == b )
+            {
+            return ETrue;
+            }
+        }
+    return EFalse;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::FindCorrectDeletedEntryAndParentL(
+    const TMsvEmailEntry& aParent,
+    const CMsvEntrySelection& aDeletedIds,
+    TFSMailMsgId& aFSParent,
+    RArray<TFSMailMsgId>& aFSDeletedArray )
+    {
+    FUNC_LOG;
+    if ( aParent.iType.iUid == KUidMsvRootEntryValue )
+        {
+        // stop recursion
+        return;
+        }
+
+    // only pop or imap types are alloved beyond this point
+    __ASSERT_DEBUG( ( aParent.iMtm.iUid == KSenduiMtmImap4UidValue ||
+            aParent.iMtm.iUid == KSenduiMtmPop3UidValue ),
+        User::Panic( KIpsPlgEventHandlerPanic, KErrGeneral ) );
+
+    TBool doRecursion = EFalse;
+
+    if ( aParent.iMtm.iUid == KSenduiMtmImap4UidValue )
+        {
+        if ( aParent.iType.iUid == KUidMsvServiceEntryValue )
+            {
+            // return in case of service / root entries to avoid
+            // forever recursion
+            return;
+            }
+        else if ( aParent.iType.iUid != KUidMsvFolderEntryValue
+            || !aParent.LocalSubscription() )
+            {
+            // some message part is deleted and main message still appears
+            // on msg store, this case happens when messages are deleted
+            // in offline state
+            doRecursion = ETrue;
+            }
+        }
+    else
+        {
+        // POP
+        if ( aParent.iType.iUid != KUidMsvServiceEntryValue )
+            {
+            if ( iBasePlugin.GetSyncStateHandler().GetMailboxIpsState(
+                    aParent.iServiceId ) != KIpsSosEmailSyncStarted )
+                {
+                // message entries parent must be service in case of POP
+                doRecursion = ETrue;
+                }
+            }
+        }
+
+
+    if ( !doRecursion )
+        {
+        aFSParent.SetPluginId( TUid::Uid( iPluginId ) );
+        aFSParent.SetId( aParent.Id() );
+        for ( TInt i = 0; i < aDeletedIds.Count(); i++ )
+            {
+            aFSDeletedArray.Append(
+                    TFSMailMsgId( iPluginId, aDeletedIds.At(i) ) );
+            }
+        }
+    else
+        {
+        TMsvEmailEntry eml;
+        TMsvId dummy;
+        if ( iSession && iSession->GetEntry( aParent.Parent(), dummy, eml )
+                == KErrNone )
+            {
+            CMsvEntrySelection* sel = new ( ELeave ) CMsvEntrySelection();
+            CleanupStack::PushL( sel );
+            sel->AppendL( aParent.Id() );
+            // recursive call
+            FindCorrectDeletedEntryAndParentL(
+                eml, *sel, aFSParent, aFSDeletedArray );
+            CleanupStack::PopAndDestroy( sel );
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SignalStartSyncL( const TFSMailMsgId& aAccount )
+    {
+    FUNC_LOG;
+    TFSMailEvent event = TFSEventMailboxSyncStateChanged;
+    TSSMailSyncState state = StartingSync;
+
+    SaveSyncStatusL( aAccount.Id(), TInt( state ) );
+
+    SendDelayedEventL(
+        event,
+        aAccount,
+        &state,
+        NULL,
+        NULL );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SignalSyncCompletedL(
+    const TFSMailMsgId& aAccount,
+    TInt aError )
+    {
+    FUNC_LOG;
+    TFSMailEvent event = TFSEventMailboxSyncStateChanged;
+
+    TSSMailSyncState state = FinishedSuccessfully;
+
+    if ( aError == KErrCancel )
+        {
+        state = SyncCancelled;
+        }
+    else if ( aError != KErrNone && aError != KErrCancel )
+        {
+        state = SyncError;
+        }
+
+    SaveSyncStatusL( aAccount.Id(), TInt( state ) );
+
+    SendDelayedEventL(
+        event,
+        aAccount,
+        &state,
+        NULL,
+        NULL );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SignalMailboxOfflineStateL(
+    const TFSMailMsgId& aAccount )
+    {
+    FUNC_LOG;
+    SendDelayedEventL(
+        TFSEventMailboxOffline,
+        aAccount,
+        NULL,
+        NULL,
+        NULL );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SettingsChangedL( TFSMailMsgId /*aAccount*/ )
+    {
+    FUNC_LOG;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SaveSyncStatusL( TMsvId aMailboxId, TInt aState )
+    {
+    FUNC_LOG;
+    TMsvEntry tEntry;
+    TMsvId service;
+    if( !iSession )
+        {
+        User::Leave( KErrNotReady );
+        }
+    TInt err = iSession->GetEntry( aMailboxId, service, tEntry );
+
+    if( err == KErrNone )
+        {
+        iSettingsApi->SaveSyncStatusL( tEntry, aState );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::HandlePropertyEventL(
+        TInt aEvent,
+        TInt aMailbox,
+        TInt /*aPluginId*/,
+        TInt aError )
+    {
+    FUNC_LOG;
+    RProcess process;
+    if ( aEvent == EIPSSosPswErr && process.SecureId() == FREESTYLE_FSSERVER_SID )
+        {
+        TFSMailMsgId mbox = SymId2FsId( aMailbox,
+                        iBasePlugin.MtmId().iUid );
+        TFSMailEvent event = TFSEventException;
+        TFsEmailNotifierSystemMessageType msg = EFsEmailNotifErrLoginUnsuccesfull;
+        SendDelayedEventL( event, mbox, &msg, NULL , (MFSMailExceptionEventCallback*)this );
+        }
+    else if ( aEvent == EIPSSosCredientialsSet || aEvent == EIPSSosCredientialsCancelled )
+        {
+        if ( iConnOpCallback )
+            {
+            iConnOpCallback->CredientialsSetL( aEvent );
+
+            //Set to null after we have used this.
+            //don't delete, we don't own this.
+            iConnOpCallback=NULL;
+            }
+        //if password was changed, we need to send settings changed event also.
+        if( aEvent == EIPSSosCredientialsSet )
+            {
+            TFSMailMsgId mbox = SymId2FsId( aMailbox,
+                    iBasePlugin.MtmId().iUid );
+            TFSMailEvent event = TFSEventMailboxSettingsChanged;
+            SendDelayedEventL( event, mbox, NULL, NULL , NULL );
+            }
+        }
+    else if ( aEvent == EIPSSosSettingsChanged )
+        {
+        TFSMailMsgId mbox = SymId2FsId( aMailbox,
+                iBasePlugin.MtmId().iUid );
+        TFSMailEvent event = TFSEventMailboxSettingsChanged;
+        SendDelayedEventL( event, mbox, NULL, NULL , NULL );
+        }
+    else if ( aEvent == KIpsSosEmailSyncCompleted &&
+            aError == KErrImapBadLogon )
+        {
+        TFSMailMsgId mbox = SymId2FsId( aMailbox,
+                        iBasePlugin.MtmId().iUid );
+        TFSMailEvent event = TFSEventException;
+        TFsEmailNotifierSystemMessageType msg = EFsEmailNotifErrLoginUnsuccesfull;
+        SendDelayedEventL( event, mbox, &msg, NULL , this );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::QueryUsrPassL( TMsvId aMbox, MIpsPlgConnectOpCallback* aCallback )
+    {
+    FUNC_LOG;
+    iConnOpCallback = aCallback;//can be null, doesn't matter.
+    SetNewPropertyEvent( aMbox, EIPSSosPswErr, 0 );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SignalCredientialsSetL( TInt aMailboxId, TBool aCancelled )
+    {
+    FUNC_LOG;
+    TInt event = EIPSSosCredientialsSet;
+    if ( aCancelled )
+        {
+        event = EIPSSosCredientialsCancelled;
+        }
+
+    SetNewPropertyEvent( aMailboxId, event, 0 );
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::SetFolderIdToArrayL( TMsvId aNewId )
+    {
+    FUNC_LOG;
+    TBool idInArray( EFalse );
+
+    for( TInt i=0; i<iImapFolderIds.Count(); i++ )
+        {
+        if( iImapFolderIds[i] == aNewId )
+            {
+            idInArray = ETrue;
+            }
+        }
+    if( !idInArray )
+        {
+        iImapFolderIds.AppendL( aNewId );
+        }
+    }
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+TBool CIpsPlgEventHandler::MatchFolderIdFound( TMsvId aDeletedId )
+    {
+    FUNC_LOG;
+    TBool match( EFalse );
+
+    for ( TInt i(iImapFolderIds.Count()-1); i >= 0; i-- )
+        {
+        if( aDeletedId == iImapFolderIds[i] )
+            {
+            iImapFolderIds.Remove( i );
+            match = ETrue;
+            }
+        }
+    return match;
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::CollectSubscribedFoldersL( TMsvId aMailboxId )
+    {
+    FUNC_LOG;
+    if ( iSession )
+        {
+        iSettingsApi->GetSubscribedImapFoldersL( aMailboxId, iImapFolderIds );
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgEventHandler::ExceptionEventCallbackL(
+        TFSMailMsgId aMailboxId,
+        TInt /*aEventType*/,
+        TBool /*aResponse*/ )
+    {
+    FUNC_LOG;
+    TFSMailEvent event = TFSEventMailboxSyncStateChanged;
+    TSSMailSyncState state = PasswordNotVerified;
+
+    SendDelayedEventL( event, aMailboxId, &state, NULL , NULL );
+    }
+
+// End of File
+