/*

* 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 )