/*
* Copyright (c) 2002-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:  MMsgMailOpObserver
*
*/



// INCLUDE FILES
#include "cmsgmailbaseop.h"
#include "mmsgmailappuiopdelegate.h"
#include "MailLog.h"
#include "MsgMailEditorDocument.h"
#include <StringLoader.h>
#include <eikenv.h>
#include <MsgEditorAppUi.rsg>
#include <MsgMailEditor.rsg>

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::CMsgMailBaseOp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMsgMailBaseOp::CMsgMailBaseOp(
    CMsgMailEditorDocument& aDocument )
    : CActive( CActive::EPriorityStandard ),
      iDocument( aDocument ),
      iState( EIdleState ),
      iWaitingError( KMaxTInt )
    {
    CActiveScheduler::Add( this );
    }

// Destructor
CMsgMailBaseOp::~CMsgMailBaseOp()
    {
    LOG( "CMsgMailBaseOp::~CMsgMailBaseOp" );
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::DoCancel
// -----------------------------------------------------------------------------
//
void CMsgMailBaseOp::DoCancel()
    {
    LOG1( "CMsgMailBaseOp::DoCancel @ iState:%d", iState );
    HandleOperationCancel(); // let subclass cancel outstanding request
    CompleteOperation( KErrCancel );
    }
    
// -----------------------------------------------------------------------------
// CMsgMailBaseOp::RunL
// -----------------------------------------------------------------------------
//
void CMsgMailBaseOp::RunL()
    {
    LOG1( "CMsgMailBaseOp::RunL @ iState:%d", iState );
    TInt completionCode = iStatus.Int();
    if ( completionCode != KErrNone )
        { // entering this branch means that latest request (iteration) was
          // completed with an error code
        LOG1( "CMsgMailBaseOp::RunL, completed with error: %d",
              completionCode );
        if ( !HandleStateActionError( completionCode ) )
            { // error wasn't handled -> complete operation
            LOG( "CMsgMailBaseOp::RunL, error wasn't handled -> stopping" );
            CompleteOperation( completionCode );
            return;
            }        
        }

    if( iWaitingError <= KErrNone && 
        iState == EIdleState )
        {
        // Wait note was dismissed and we can complete the operation.
        LOG1( "CMsgMailBaseOp::RunL, wait note dismissed -> operation done: %d", 
            iWaitingError );
        NotifyObservers( iWaitingError );
        }
    else
        {
        // Start handling next state
        SetNextState();
        
        if ( iState == EIdleState )
            {
            CompleteOperation( KErrNone );
            }
        else
            {
            HandleStateActionL(); // call subclass to handle the action
            }
        }
    }
    
// -----------------------------------------------------------------------------
// CMsgMailBaseOp::RunError
// -----------------------------------------------------------------------------
//
TInt CMsgMailBaseOp::RunError( TInt aError )
    {   
    LOG2( "CMsgMailBaseOp::RunError @ iState: %d, aError:%d", iState, aError );

    // Usually we must return KErrNone, but with KLeaveExit,KErrDiskFull and KErrNoMemory
    // we must return error code.  
    // We have to return KLeaveExit to get appui deleted. We also don't want
    // to notify observer anymore in that case.
    // KErrDiskFull and KErrNoMemory are returned because otherwise error note is not shown.
    if ( aError == KLeaveExit )
        {        
        LOG1("ERROR %d", aError);
        return aError;
        }
    else if(aError == KErrDiskFull || aError == KErrNoMemory)
        {
        LOG1("ERROR KErrDiskFull or KErrNoMemory: %d", aError);
        CompleteOperation( KErrCancel );
        return aError;
        }    
    else if ( HandleStateActionError( aError ) )
        { // error was handled -> we can continue with next step
        LOG( "CMsgMailBaseOp::RunError, error was handled" );
        return KErrNone;
        }
    else
        { // error wasn't handled -> complete operation
        LOG( "CMsgMailBaseOp::RunError, error wasn't handled -> stopping" );
        CompleteOperation( aError );
        return KErrNone;
        }
    }


// -----------------------------------------------------------------------------
// CMsgMailBaseOp::DialogDismissedL
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::DialogDismissedL( TInt /*aButtonId*/ )
    {
    LOG( "CMsgMailBaseOp::DialogDismissedL" );    
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
    SetActive();
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::HandleStateActionError
// -----------------------------------------------------------------------------
//    
TBool CMsgMailBaseOp::HandleStateActionError( TInt /*aError*/ )
    {
    // By default errors are not handled or tolerated
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::StartOp
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::StartOp( MMsgMailOpObserver& aObserver )
    {
    LOG( "CMsgMailBaseOp::StartOp" );
    Cancel();
    ASSERT( iState == EIdleState );
    iObserver = &( aObserver );
    // start iterating through operation states
    CompleteStateAction();    
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::StartOp
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::StartOp( TRequestStatus& aStatus )
    {
    LOG( "CMsgMailBaseOp::StartOp" );
    Cancel();
    ASSERT( iState == EIdleState );
    iExtRequestStatus = &( aStatus );
    *iExtRequestStatus = KRequestPending;
    // start iterating through operation states
    CompleteStateAction();    
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::CompleteStateAction
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::CompleteStateAction( TInt aError )
    {
    LOG1( "CMsgMailBaseOp::CompleteStateAction @ aError:%d", aError );
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, aError );         
    SetActive();
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::CompleteOperation
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::CompleteOperation( TInt aError )
    {
    LOG1( "CMsgMailBaseOp::CompleteOperation @ aError:%d", aError );
    iState = EIdleState;
    StopWaitNote(); // not necessarily started
    
    if( iWaitDialog )
        {
        // wait note is still active. we have to wait for it before 
        // completing the operation.
        iWaitDialog->SetCallback( this );
        iWaitingError = aError;
        }
    else
        {
        // Nothing to wait, we can complete now.
        NotifyObservers( aError );
        }
    }

// -----------------------------------------------------------------------------
// CMsgMailBaseOp::NotifyObservers
// -----------------------------------------------------------------------------
//    
void CMsgMailBaseOp::NotifyObservers( TInt aError )
    {
    LOG1( "CMsgMailBaseOp::NotifyObservers @ aError:%d", aError );
    if ( iObserver )
        {        
        iObserver->HandleOpCompleted( *this, aError );
        iObserver =  NULL; // mustn't reuse observer
        }
    if ( iExtRequestStatus )
        {
        LOG( "NotifyObservers, completing external request" );
        ASSERT( iExtRequestStatus );
        User::RequestComplete( iExtRequestStatus, aError );
        iExtRequestStatus = NULL; // mustn't reuse request status
        }
    }

// ----------------------------------------------------------------------------
// CMsgMailBaseOp::StartWaitNoteL
// ----------------------------------------------------------------------------
//
void CMsgMailBaseOp::StartWaitNoteL(
    TInt aTextResourceId,
    TBool aDelayOff,
    TInt aResouceID )
    {
    LOG( "CMsgMailBaseOp::StartWaitNoteL" );
    StopWaitNote();
    iWaitDialog = new( ELeave ) CAknWaitDialog(
        reinterpret_cast<CEikDialog**>( &iWaitDialog ), aDelayOff );
    iWaitDialog->PrepareLC( aResouceID );
    HBufC* text = StringLoader::LoadLC( aTextResourceId, CEikonEnv::Static() );		// CSI: 27 # Must be used because of 
    																				// iEikEnv is not accessible.
    iWaitDialog->SetTextL( *text );
    CleanupStack::PopAndDestroy( text ); // text    

	// safe to call LD even as a member variable, since sets itself to NULL when deleting
    iWaitDialog->RunLD(); // CSI: 50 # see comment above
    }
  
// ----------------------------------------------------------------------------
// CMsgMailBaseOp::StopWaitNote
// ----------------------------------------------------------------------------
//  
void CMsgMailBaseOp::StopWaitNote()
    {
    LOG( "CMsgMailBaseOp::StopWaitNote" );
    if ( iWaitDialog )
        {
        TRAP_IGNORE( iWaitDialog->ProcessFinishedL() );
        LOG1( "StopWaitNote - process finished @ iWaitDialog:%x",  iWaitDialog );
        }
    }
    
// End Of File