/*

* Copyright (c) 2007-2008 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:  IMAP4 connect operation

*

*

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::NewL()

// ----------------------------------------------------------------------------

CIpsPlgImap4ConnectOp* CIpsPlgImap4ConnectOp::NewL(

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aService,

    CIpsPlgTimerOperation& aActivityTimer,

    TFSMailMsgId aFSMailBoxId,

    TInt aFSRequestId,

    CIpsPlgEventHandler* aEventHandler,

    {

    FUNC_LOG;

    CIpsPlgImap4ConnectOp* self = new (ELeave) CIpsPlgImap4ConnectOp(

        aMsvSession, 

        aObserverRequestStatus,

        aService, 

        aActivityTimer,

        aFSMailBoxId, 

        aFSOperationObserver,

        aFSRequestId,

        aDoPlainConnect,

        aEventHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::CIpsPlgImap4ConnectOp()

// ----------------------------------------------------------------------------

CIpsPlgImap4ConnectOp::CIpsPlgImap4ConnectOp(

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aService,

    CIpsPlgTimerOperation& aActivityTimer,

    TFSMailMsgId aFSMailBoxId,

    TInt aFSRequestId,

    TBool aDoPlainConnect,

    CIpsPlgEventHandler* aEventHandler)

    :

    CIpsPlgOnlineOperation(

	    aMsvSession,

	    aObserverRequestStatus,

	    aActivityTimer,

	    aFSMailBoxId,

	    aFSOperationObserver,

    iDoPlainConnect( aDoPlainConnect ),

    iEventHandler( aEventHandler ),

    {

    FUNC_LOG;

    iService = aService;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::~CIpsPlgImap4ConnectOp()

// ----------------------------------------------------------------------------

// 

CIpsPlgImap4ConnectOp::~CIpsPlgImap4ConnectOp()

    {

    FUNC_LOG;

    Cancel();

    delete iSelection;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::ConstructL()

// ----------------------------------------------------------------------------

// 

void CIpsPlgImap4ConnectOp::ConstructL()

    {

    FUNC_LOG;

    BaseConstructL( KUidMsgTypeIMAP4 ); 

    iSelection = new(ELeave) CMsvEntrySelection;

    TMsvEntry tentry;

    TMsvId service;

    iMsvSession.GetEntry( iService, service, tentry );

    if ( tentry.iType.iUid != KUidMsvServiceEntryValue )

        {

        User::Panic( KIpsPlgIpsConnPanic, KErrNotSupported );

        }

        }

    else

        {

        iState = EStateStartConnect;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::ProgressL()

// ----------------------------------------------------------------------------

//

const TDesC8& CIpsPlgImap4ConnectOp::ProgressL()

    {

    FUNC_LOG;

    if( iError != KErrNone )

        {

        return GetErrorProgressL( iError );

        }

        {

        }

    TImap4CompoundProgress& prog = iProgressBuf();

    prog.iGenericProgress.iErrorCode = KErrNone;

    return iProgressBuf;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::GetErrorProgressL()

// ----------------------------------------------------------------------------    

//   

const TDesC8& CIpsPlgImap4ConnectOp::GetErrorProgressL(TInt aError)

    {

    FUNC_LOG;

    TImap4CompoundProgress& prog = iProgressBuf();

    prog.iGenericProgress.iErrorCode = aError;      

    return iProgressBuf;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::GetFSProgressL()

// ----------------------------------------------------------------------------

// 

TFSProgress CIpsPlgImap4ConnectOp::GetFSProgressL() const

    {

    FUNC_LOG;

    // might not never called, but gives something reasonable if called

    TFSProgress result = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };

    result.iError = KErrNone;

    switch( iState )

        {

        case EStateStartConnect:

            result.iProgressStatus = TFSProgress::EFSStatus_Started;

            break;

        case EStateConnectAndSync:

            result.iProgressStatus = TFSProgress::EFSStatus_Connecting;

            break;

        case EStateCompleted:

        default:

            result.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;

            break;

        }

    if ( iStatus.Int() == KErrCancel )

        {

        result.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;

        result.iError = KErrCancel;

        }

    return result;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::IpsOpType()

// ----------------------------------------------------------------------------

    {

    FUNC_LOG;

    return EIpsOpTypeImap4SyncOp;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::DoCancel()

// ----------------------------------------------------------------------------

// 

void CIpsPlgImap4ConnectOp::DoCancel()

    {

    FUNC_LOG;

        {

        }

    SignalSyncCompleted( KErrCancel );

    CompleteObserver( KErrCancel );

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::DoRunL()

// ----------------------------------------------------------------------------    

//  

void CIpsPlgImap4ConnectOp::DoRunL()

    {

    FUNC_LOG;

        {

        }

    switch( iState )

        {

            DoConnectOpL();

            break;

        case EStateConnectAndSync:

            // Connection completed

                {

                }

                {

                // no errors in connection

                if( !iDoPlainConnect )

                    {

                    DoPopulateAllL();

                    }

                else

                    {

                    // Get on with others using this class for connection only

                    iState = EStateIdle;

                    CompleteThis();

                    }

                }

            break;

        case EStatePopulateAllCompleted:

            // break command is intentially left out

        case EStateCompleted:

            if ( err == KErrNone )

                {

                iState = EStateIdle;

                CompleteThis();

                }

            break;

        case EStateIdle:

        default:

                {

                }

            CompleteObserver();

            break;

        }

    // if iError < 0, observer is completed in base class

    iError = err;

    if ( err != KErrNone )

        {

        SignalSyncCompleted( err );

        }

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::RequestResponseL()

// ----------------------------------------------------------------------------    

//   

void CIpsPlgImap4ConnectOp::RequestResponseL( 

    TFSProgress /*aEvent*/, TInt /*aRequestId*/ )

    {

    FUNC_LOG;

    }

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::DoConnectOpL()

// ----------------------------------------------------------------------------    

//   

void CIpsPlgImap4ConnectOp::DoConnectOpL()

	{

    FUNC_LOG;

    iBaseMtm->SwitchCurrentEntryL( iService );

    iSelection->ResizeL(0);

    iSelection->AppendL(iService);

    if ( iDoPlainConnect && !Connected() )

        {

        TBuf8<1> parameter;

        // connect and synchronise starts background sync or idle

        }

    else if ( Connected() )

        {

        // in this point cant use "connect and do something" commands,

        // use regular sync, when new mails is populated elsewhere.

        TBuf8<1> parameter;

        }

    else

        {

        }

	}

// ----------------------------------------------------------------------------

// CIpsPlgImap4ConnectOp::DoPopulateAll()

// ---------------------------------------------------------------------------- 

void CIpsPlgImap4ConnectOp::DoPopulateAllL()

    {

    FUNC_LOG;

    // construct partial fetch info according to imap settings

    TImImap4GetPartialMailInfo info;

    TPckgBuf<TImImap4GetPartialMailInfo> package(info);

    if ( info.iTotalSizeLimit != KIpsSetDataHeadersOnly )

        {

        iStatus = KRequestPending;

        iBaseMtm->SwitchCurrentEntryL( iService );

        SetActive();

        }

    else

        {

        CompleteThis();

        }

    iState = EStatePopulateAllCompleted;

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------       

void CIpsPlgImap4ConnectOp::SignalSyncStarted()

    {

    FUNC_LOG;

    if ( iEventHandler && !iIsSyncStartedSignaled )

        {

        // mark that sync is signaled to prevent 

        // sending necessary event

        iIsSyncStartedSignaled = ETrue;

        }

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------       

void CIpsPlgImap4ConnectOp::SignalSyncCompleted( TInt aError )

    {

    FUNC_LOG;

        {

        iIsSyncStartedSignaled = EFalse;

        }

    }

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------