/*
* Copyright (c) 2006 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: 
*       IpsPlgImap4FetchAttachmentOp implementation file
*
*/


#include "emailtrace.h"
#include "ipsplgheaders.h"

// <qmail> priority const has been removed, interval changed to 0.2 sec
const TInt KIpsAttaFetchProgressReportInterval = 200000; // 0.2 sec
const TInt KIpsAttaFetchRetryInterval = 1000000; // 1 sec
const TInt KIpsAttaFetchRetryCount = 30;

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
CIpsFetchProgReport* CIpsFetchProgReport::NewL( 
    CIpsPlgImap4FetchAttachmentOp& aAttaOp )
    {
    FUNC_LOG;
    CIpsFetchProgReport* self = new (ELeave) CIpsFetchProgReport( aAttaOp );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    return self;
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------    
CIpsFetchProgReport::CIpsFetchProgReport( 
    CIpsPlgImap4FetchAttachmentOp& aAttaOp ) : 
    CActive( CActive::EPriorityStandard ), 
    iAttaOp(aAttaOp)
    {
    FUNC_LOG;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------    
CIpsFetchProgReport::~CIpsFetchProgReport()
    {
    FUNC_LOG;
    Cancel();
    iTimer.Close();
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------	    
void CIpsFetchProgReport::ConstructL()
    {
    FUNC_LOG;
    CActiveScheduler::Add(this);
    User::LeaveIfError( iTimer.CreateLocal() );
    AdjustTimer();
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsFetchProgReport::AdjustTimer()   
    {
    FUNC_LOG;
    TTimeIntervalMicroSeconds32 sec( KIpsAttaFetchProgressReportInterval ); 
    TTime time;
    time.HomeTime();
    time = time + sec;
    iTimer.At(iStatus, time);
    SetActive();    
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------    
void CIpsFetchProgReport::DoCancel()
    {
    FUNC_LOG;
    iTimer.Cancel();
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------	
void CIpsFetchProgReport::RunL()
    {
    FUNC_LOG;
    iAttaOp.ReportProgressL();
    AdjustTimer();
    }

// ----------------------------------------------------------------------------
// CIpsPlgImap4FetchAttachmentOp
// ----------------------------------------------------------------------------
// <qmail> aFunctionId removed, CMsvEntrySelection& changed to pointer
// <qmail> MFSMailRequestObserver& changed to pointer
CIpsPlgImap4FetchAttachmentOp* CIpsPlgImap4FetchAttachmentOp::NewL(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    TMsvId aService,
    CIpsPlgTimerOperation& aActivityTimer,
    const CMsvEntrySelection* aSelection,
    TFSMailMsgId aFSMailBoxId,
    MFSMailRequestObserver* aFSOperationObserver,
    TInt aFSRequestId )
    {
    FUNC_LOG;
    CIpsPlgImap4FetchAttachmentOp* op = new (
        ELeave) CIpsPlgImap4FetchAttachmentOp(
        aMsvSession,
        aObserverRequestStatus,
        aService,
        aActivityTimer,
        aSelection,
        aFSMailBoxId,
        aFSOperationObserver,
        aFSRequestId );
        
    CleanupStack::PushL( op );
    op->ConstructL();
    CleanupStack::Pop( op );
    return op;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// <qmail> priority parameter has been removed
// <qmail> MFSMailRequestObserver& changed to pointer
CIpsPlgImap4FetchAttachmentOp::CIpsPlgImap4FetchAttachmentOp(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    TMsvId aService,
    CIpsPlgTimerOperation& aActivityTimer,
    const CMsvEntrySelection* aSelection,
    TFSMailMsgId aFSMailBoxId,
    MFSMailRequestObserver* aFSOperationObserver,
    TInt aFSRequestId )
    :
    CIpsPlgOnlineOperation(
        aMsvSession,
        aObserverRequestStatus,
        aActivityTimer,
        aFSMailBoxId,
        aFSOperationObserver,
        aFSRequestId ),
    	iSelection( aSelection ),
    	iRetryCount( 0 )
    {
    FUNC_LOG;
    iService = aService;
    iRetryTimer.CreateLocal();
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
CIpsPlgImap4FetchAttachmentOp::~CIpsPlgImap4FetchAttachmentOp()
    {
    FUNC_LOG;
    iRetryTimer.Close();
    delete iSelection;
    delete iProgReport;
    delete iFetchErrorProgress;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::ConstructL()
    {
    FUNC_LOG;
    BaseConstructL( KUidMsgTypeIMAP4 );
    DoConnectL();
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::DoConnectL()
    {
    FUNC_LOG;
    iState = EStateConnecting;
    iStatus = KRequestPending;

    // <qmail> priority parameter has been removed
    CIpsPlgImap4ConnectOp* connOp = CIpsPlgImap4ConnectOp::NewL(
        iMsvSession,
        iStatus, 
        iService,
        *iActivityTimer,
        iFSMailboxId,
        NULL, // no observer for subopertaion
        0,    // no requestId needed
        NULL, // event handler not needed whin plain connect
        ETrue );
        
    delete iSubOperation;
    iSubOperation = connOp;

    SetActive();
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::RunL()
    {
    FUNC_LOG;
    TRAPD(err, DoRunL());
    if(err != KErrNone)
        {
        iProgress().iGenericProgress.iErrorCode = err;
        Complete();
        }
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::DoRunL()
    {
    FUNC_LOG;
    switch( iState )
        {
        case EStateConnecting:
            {
            // <qmail> Connected() usage
            if ( !Connected() )
                {
                CompleteObserver( KErrCouldNotConnect );
                return;
                }
            iRetryCount = 0;
            DoFetchAttachmentL();
            break;
            }
        case EStateWaiting:
            {
            DoFetchAttachmentL();
            break;
            }
        case EStateFetching:         
            {
            delete iProgReport;
            iProgReport = NULL;
            
            TInt err = iStatus.Int();

            // If the server was busy, try again after a short delay, up to
            // some retry limit.
            if ( err == KErrServerBusy && iRetryCount < KIpsAttaFetchRetryCount )
                {
                iRetryCount++;
                INFO_1( "CIpsPlgImap4FetchAttachmentOp::DoRunL: iRetryCount = %d", iRetryCount );
                iState = EStateWaiting;
                iStatus = KRequestPending;
                iRetryTimer.After( iStatus, KIpsAttaFetchRetryInterval );
                SetActive();
                }
            else
                {
                if( err != KErrNone && iSubOperation )
                    {
                    iFetchErrorProgress = iSubOperation->ProgressL().AllocL();
                    }
                
                iState = EStateIdle;
                CompleteObserver( err );
                }
            break;
            }
        default:
            break;
        }
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
const TDesC8& CIpsPlgImap4FetchAttachmentOp::ProgressL()
    {
    FUNC_LOG;
    if(iFetchErrorProgress && (iState == EStateIdle))
        {
        // Completed, but with an error during fetch.
        return *iFetchErrorProgress;
        }
    
    if ( iSubOperation )
        {
        iProgress.Copy( iSubOperation->ProgressL() );
        }
    else
        {
        TImap4CompoundProgress progg;
        progg.iGenericProgress.iErrorCode = KErrNone;
        progg.iGenericProgress.iState = TImap4GenericProgress::EIdle;
        iProgress.Copy( TPckgBuf<TImap4CompoundProgress>(progg) );
        }
           
    return iProgress;
    }
    
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::ReportProgressL()
    {
    FUNC_LOG;
        
    TInt error = KErrNone;

    TFSProgress fsProgress = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };
    if ( iSubOperation && iState == EStateFetching )
        {
        TRAP(error, iProgress.Copy( iSubOperation->ProgressL() ) );
        }
    
    if ( error == KErrNone )
        {
        const TImap4GenericProgress& progg = iProgress().iGenericProgress;
        fsProgress.iProgressStatus = TFSProgress::EFSStatus_Status;
        fsProgress.iMaxCount = progg.iBytesToDo;
        fsProgress.iCounter = progg.iBytesDone;
        fsProgress.iError = progg.iErrorCode;
        }
    else if ( error == KErrNotReady )
        {
        // This error indicates that operation not started yet
        // and waiting to other operation compleion
        fsProgress.iProgressStatus = TFSProgress::EFSStatus_Waiting;
        fsProgress.iMaxCount = 1;
        fsProgress.iCounter = 0;
        fsProgress.iError = KErrNone;
        }
    else
        {
        User::Leave( error );
        }

    TInt fileSize( 0 );
    
    if ( fsProgress.iMaxCount - fsProgress.iCounter > 0 )
        {
        fileSize = fsProgress.iMaxCount - fsProgress.iCounter;
        }

    if ( EnoughDiskSpaceOnCurrentDrive( fileSize ) == EFalse )
        {
        // Not enough space on the disk for the attachment!
        error = KErrDiskFull;
        fsProgress.iError = error;
        }

// <qmail>
    // signal observer if it exists
    if ( iFSOperationObserver )
        {
        iFSOperationObserver->RequestResponseL( fsProgress, iFSRequestId );
        }
// </qmail>
    
    if ( error == KErrDiskFull )
        {
        Cancel();
        }
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
const TDesC8& CIpsPlgImap4FetchAttachmentOp::GetErrorProgressL(TInt /*aError*/ )
    {
    return *iFetchErrorProgress;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
TFSProgress CIpsPlgImap4FetchAttachmentOp::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 EStateConnecting:
            result.iProgressStatus = TFSProgress::EFSStatus_Connecting;
            break;
        case EStateFetching:
            result.iProgressStatus = TFSProgress::EFSStatus_Connected;
            break;
        default:
            result.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;
            break;
        }
    if ( iStatus.Int() == KErrCancel )
        {
        result.iProgressStatus = TFSProgress::EFSStatus_RequestCancelled;
        result.iError = KErrCancel;
        }
    
    return result;
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::Complete()
    {
    FUNC_LOG;
    TRequestStatus* observer=&iObserverRequestStatus;
    User::RequestComplete(observer, KErrNone);
    }

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CIpsPlgImap4FetchAttachmentOp::DoFetchAttachmentL( )
    {
    FUNC_LOG;
    iState = EStateFetching;

    // Switch operations.
    delete iSubOperation;
    iSubOperation = NULL;
    iStatus = KRequestPending;

    iProgReport = CIpsFetchProgReport::NewL( *this );

    // Filters are not used when performing 'fetch' operation, 
    // use normal getmail info instead
// <qmail>
    TPckgBuf<TImImap4GetMailInfo> param;
    TImImap4GetMailInfo& options = param();
    options.iMaxEmailSize = KMaxTInt32;
    options.iGetMailBodyParts = EGetImap4EmailAttachments;
    options.iDestinationFolder = 0; // not used

    InvokeClientMtmAsyncFunctionL( KIMAP4MTMPopulate, *iSelection, param ); // <qmail> 1 param removed
// </qmail>
    SetActive();
    }
    
// <qmail> GetEngineProgress function removed

// <qmail> new func to this op
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------    
TIpsOpType CIpsPlgImap4FetchAttachmentOp::IpsOpType() const
    {
    FUNC_LOG;
    return EIpsOpTypeFetchAttachmentOp;
    }
// </qmail>


// End of File