/*

* 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:  POP3 connect operation

*

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

// Constants and defines

const TInt KConnectOpPriority = CActive::EPriorityStandard;

const TInt KIpsPlgPop3PopulateLimitInitValue = 50;

_LIT( KIpsPlgPopConnectPanic, "PopConnectOp" );

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

// CIpsPlgPop3ConnectOp::NewL()

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

//

CIpsPlgPop3ConnectOp* CIpsPlgPop3ConnectOp::NewL(

    CMsvSession& aMsvSession,                           

    TRequestStatus& aObserverRequestStatus,

    TMsvId aService,

    TBool aForcePopulate,

    CIpsPlgTimerOperation& aActivityTimer,

    TFSMailMsgId aFSMailBoxId,

    MFSMailRequestObserver& aFSOperationObserver,

    TInt aFSRequestId,

    CIpsPlgEventHandler* aEventHandler,

    TBool aSignallingAllowed )

    {

    FUNC_LOG;

    CIpsPlgPop3ConnectOp* op = 

        new(ELeave) CIpsPlgPop3ConnectOp( aMsvSession, aObserverRequestStatus, 

            aService, aForcePopulate, aActivityTimer, aFSMailBoxId,

            aFSOperationObserver, aFSRequestId, 

            aEventHandler, aSignallingAllowed );

    CleanupStack::PushL( op );

    op->ConstructL();

    CleanupStack::Pop( op );

    return op;

    }

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

// CIpsPlgPop3ConnectOp::~CIpsPlgPop3ConnectOp()

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

//

CIpsPlgPop3ConnectOp::~CIpsPlgPop3ConnectOp()

    {

    FUNC_LOG;

    delete iEntry;

    delete iSelection;

    iState = EIdle;

    }

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

// CIpsPlgPop3ConnectOp::ProgressL()

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

//

const TDesC8& CIpsPlgPop3ConnectOp::ProgressL()

    {

    FUNC_LOG;

    if( iError != KErrNone )

        {

        return GetErrorProgressL( iError );

        }

    else if( iOperation )

        {

        return iOperation->ProgressL();

        }

    iProgress().iErrorCode = KErrNone;

    return iProgress;    

    }   

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

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

//

void CIpsPlgPop3ConnectOp::DoCancel()

    {

    FUNC_LOG;

    if( iOperation )

        {

        iOperation->Cancel();

        }

    CompleteObserver( KErrCancel );

    }

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

// CIpsPlgPop3ConnectOp::DoRunL()

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

//

void CIpsPlgPop3ConnectOp::DoRunL()

    {

    FUNC_LOG;

    // handle these error situations properly, 

    // and report somehow back to framework

    TInt err  = KErrNone;

    if ( iState == EQueryingDetails )

        {

        // Retry connect.

        DoConnectL();

        iState = EConnected;

        }       

    else if ( iState == EStartConnect )

        {

        if ( iOperation )

            {

            // operation exist and it means 

            // disconnect operation was ongoing.

            // How handle errors

            delete iOperation;

            iOperation = NULL;

            }

        if ( ValidateL() )

            {

            // Begin Connect.

            DoConnectL();

            iState = EConnected;

            }

        else

            {

            User::Leave( KErrCancel );    // User cancelled.

            }

        }

    else if ( iState == EConnected )

        {

        // Connect completed.

        err = GetOperationErrorCodeL( );

        if ( ( err == KPop3InvalidUser ) ||

             ( err == KPop3InvalidLogin )  ||

             ( err == KPop3InvalidApopLogin ) )

            {

            }

        else if ( err == KErrNone )

            {

            if ( iForcePopulate && Connected() )

                {

                iState = EPopulate;

                DoPopulateL();

                }

            else

                {

                iState = EIdle;

                CompleteObserver( KErrNone );

                }

            }

        else

            {

            // We can't do this before, because 

            // we want to handle KPop3InvalidUser,

            // KPop3InvalidLogin and KPop3InvalidApopLogin separately.

            User::Leave( err );

            }

        }

    else if ( iState == EPopulate )

        {

        err = GetOperationErrorCodeL( );

        if ( iEventHandler )

            {

            iEventHandler->SetNewPropertyEvent( 

                    iService, KIpsSosEmailSyncCompleted, err );

            }

        CIpsPlgSyncStateHandler::SaveSuccessfulSyncTimeL(

                iMsvSession, iService );

        CompleteObserver( err ); 

        }

    else

        {

        User::Panic( KIpsPlgPopConnectPanic ,KErrNotFound);

        }

    }

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

// CIpsPlgPop3ConnectOp::GetErrorProgressL

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

//

const TDesC8& CIpsPlgPop3ConnectOp::GetErrorProgressL( TInt aError )

    {

    FUNC_LOG;

    iError = aError;

    if ( iOperation && iError == KErrNone )

        {

        return iOperation->ProgressL();

        }

    TPop3Progress& progress = iProgress();

    progress.iPop3Progress = TPop3Progress::EPopConnecting;

    progress.iTotalMsgs = 0;

    progress.iMsgsToProcess = 0;

    progress.iBytesDone = 0;

    progress.iTotalBytes = 0;

    progress.iErrorCode = iError;

    progress.iPop3SubStateProgress = TPop3Progress::EPopConnecting;

    progress.iServiceId = iService;

    return iProgress;

    }

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

// CIpsPlgPop3ConnectOp::GetFSProgressL()

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

//

TFSProgress CIpsPlgPop3ConnectOp::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 EQueryingDetails:

            result.iProgressStatus = TFSProgress::EFSStatus_Authenticating;

            break;

        case EStartConnect:

        case EConnected:

            result.iProgressStatus = TFSProgress::EFSStatus_Connecting;

            break;

        case EPopulate:

            // staus is used to inform fetching in base plugin

            result.iProgressStatus = TFSProgress::EFSStatus_Status;

            break;

        default:

            result.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;

            break;

        }

    if ( iStatus.Int() == KErrCancel )

        {

        result.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;

        result.iError = KErrCancel;

        }

    return result;

    }

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

// CIpsPlgPop3ConnectOp::CIpsPlgPop3ConnectOp

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

//

CIpsPlgPop3ConnectOp::CIpsPlgPop3ConnectOp(

    CMsvSession& aMsvSession,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aServiceId,

    TBool aForcePopulate,

    CIpsPlgTimerOperation& aActivityTimer,

    TFSMailMsgId aFSMailBoxId,

    MFSMailRequestObserver& aFSOperationObserver,

    TInt aFSRequestId,

    CIpsPlgEventHandler* aEventHandler,

    TBool aSignallingAllowed )

    :

    CIpsPlgOnlineOperation( aMsvSession, KConnectOpPriority,

        aObserverRequestStatus, aActivityTimer, aFSMailBoxId,

        aFSOperationObserver, aFSRequestId, aSignallingAllowed ),

    iState( EIdle ),

    iEntry( NULL ),

    iPopulateLimit( KIpsPlgPop3PopulateLimitInitValue ),

    iForcePopulate( aForcePopulate ),

    iSelection( NULL ),

    iEventHandler( aEventHandler ),

    iAlreadyConnected( EFalse )

    {

    iService = aServiceId; 

    }

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

// CIpsPlgPop3ConnectOp::ConstructL()

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

//

void CIpsPlgPop3ConnectOp::ConstructL()

    {

    FUNC_LOG;

    BaseConstructL( KUidMsgTypePOP3 );

    iEntry = iMsvSession.GetEntryL( iService );

    if ( !iEntry )

        {

        User::Leave( KErrGeneral );

        }

    iSelection = new(ELeave) CMsvEntrySelection;

    const TMsvEntry& tentry = iEntry->Entry();

    if ( tentry.iType.iUid != KUidMsvServiceEntryValue )

        {

        // should we panic with own codes?

        User::Leave( KErrNotSupported );

        }

    // get correct populate and sync limet values from settings

    CImPop3Settings* settings = new(ELeave) CImPop3Settings();

    CleanupStack::PushL( settings );

    TPopAccount popAccountId;

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    accounts->GetPopAccountL( iService , popAccountId );

    accounts->LoadPopSettingsL( popAccountId, *settings );

    iPopulateLimit = settings->PopulationLimit();

    if ( iPopulateLimit > 0 )

        {

        iPopulateLimit = ( iPopulateLimit * 1024 ) / 75;

        }

    else if ( iPopulateLimit == KIpsSetDataHeadersOnly )    

        {

        iPopulateLimit = 0;

        }

    else

        {

        iPopulateLimit = KMaxTInt;

        }

    CleanupStack::PopAndDestroy( 2, settings );

    if ( tentry.Connected() )

        {      

        iState = EConnected; 

        iAlreadyConnected = ETrue;

        SetActive();

        CompleteThis();

        }

    else

        {

        iState = EStartConnect; 

        SetActive();

        CompleteThis();

        }    

    }

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

// CIpsPlgPop3ConnectOp::DoConnectL()

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

//

void CIpsPlgPop3ConnectOp::DoConnectL()

    {

    FUNC_LOG;

    iStatus = KRequestPending;

    InvokeClientMtmAsyncFunctionL( KPOP3MTMConnect, iService, iService );

    SetActive();

    }

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

// CIpsPlgPop3ConnectOp::DoPopulateL()

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

//

void CIpsPlgPop3ConnectOp::DoPopulateL()

    {

    FUNC_LOG;

    iStatus = KRequestPending;

    // Prepare parameters and include filtering

    TImPop3PopulateOptions pop3GetMailInfo;

    pop3GetMailInfo.SetMaxEmailSize( KMaxTInt32 );

    pop3GetMailInfo.SetPopulationLimit( iPopulateLimit );

    TPckgBuf<TImPop3PopulateOptions> params( pop3GetMailInfo );

    iSelection->InsertL(0, iService);

    iBaseMtm->SwitchCurrentEntryL( iService );

    // Start the fetch operation

    InvokeClientMtmAsyncFunctionL( KPOP3MTMPopulateAll, *iSelection,

        iService, params);

    SetActive();

    if ( iEventHandler )

        {

        iEventHandler->SetNewPropertyEvent( 

                iService, KIpsSosEmailSyncStarted, KErrNone );

        } 

    }

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

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

//

TBool CIpsPlgPop3ConnectOp::Connected() const

    {

    FUNC_LOG;

    TMsvEntry tentry;

    TMsvId service;

    iMsvSession.GetEntry(iService, service, tentry );

    return tentry.Connected();

    }

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

// CIpsPlgImap4ConnectOp::IpsOpType()

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

// 

TInt CIpsPlgPop3ConnectOp::IpsOpType() const

    {

    FUNC_LOG;

    return EIpsOpTypePop3SyncOp;

    }

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

// CIpsPlgPop3ConnectOp::ValidateL()

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

//

TBool CIpsPlgPop3ConnectOp::ValidateL()

    {

    // do proper validation. OR: not needed?

    return ETrue;

    }

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

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

//

    {

    FUNC_LOG;

    if ( iEventHandler )

        {

        }

    }

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

// CIpsPlgPop3ConnectOp::GetOperationErrorCodeL()

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

// 

TInt CIpsPlgPop3ConnectOp::GetOperationErrorCodeL( )

    {

    FUNC_LOG;

    if ( iAlreadyConnected )

        {

        // Connected state was set in CIpsPlgPop3ConnectOp::ConstructL()

        // so iOperation is null

        return KErrNone;

        }

    if ( !iOperation )

        {

        return KErrNotFound;

        }

    if ( !iOperation->IsActive() && iOperation->iStatus.Int() != KErrNone )

        {

        return iOperation->iStatus.Int();

        }

    TPckgBuf<TPop3Progress> paramPack;

    paramPack.Copy( iOperation->ProgressL() );

    const TPop3Progress& progress = paramPack();

    return progress.iErrorCode;

    }

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

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

void CIpsPlgPop3ConnectOp::CredientialsSetL( TInt aEvent )

    FUNC_LOG;

        {

        CompleteObserver( KErrCancel );

        }

    }

//EOF