/*
* 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:  Operation base class implementation.
*
*/



// INCLUDE FILES
#include    "CVtEngOperation.h"
#include    "CVtEngCommandHandler.h"
#include    "TVtEngOperationUtils.h"
#include    "VtEngUtils.h"
#include    "cvtengmdtrcommandsender.h"
#include    "cvtlogger.h"

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

// -----------------------------------------------------------------------------
// CVtEngOperation::NewL
// Symbian two-phase constructor
//
// -----------------------------------------------------------------------------
//
CVtEngOperation* CVtEngOperation::NewL(
    TVtEngCommandId aCommandId,
    CVtEngHandlerContainer& aHandlers,
    MVtEngOperationObserver& aObserver,
    TBool aDelete )
    {
    CVtEngOperation* self = new ( ELeave )
    CVtEngOperation( aCommandId, aHandlers, aObserver, aDelete );
    
    CleanupStack::PushL( self );
    self->iAsyncCallback = new ( ELeave )
        CAsyncCallBack( CActive::EPriorityStandard );
    self->iAsyncCallback->Set( TCallBack( ASyncHandleOpComplete, self ) );

    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::CVtEngOperation
// C++ constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtEngOperation::CVtEngOperation(
    TVtEngCommandId aCommandId,
    CVtEngHandlerContainer& aHandlers,
    MVtEngOperationObserver& aObserver,
    TBool aDelete ) :
    iCommand( aCommandId ),
    iHandlers( aHandlers ),
    iObserver( aObserver ),
    iDelete( aDelete )
    {
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::~CVtEngOperation
// Destructor
//
// -----------------------------------------------------------------------------
//
CVtEngOperation::~CVtEngOperation()
    {
    Cancel();
    delete iAsyncCallback;
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::HandleOpCompleteL
// Destructor
//
// -----------------------------------------------------------------------------
//
void CVtEngOperation::HandleOpComplete( const TInt aResult )
    {
    __VTPRINTENTER( "EngOp.HandleOpComplete" )
    iObserver.SetOperation( NULL );
    CVtEngMdtrCommandSender& mediatorSender = 
        CVtEngUtility::EngineUtils()->MediatorCommands();
    switch( iCommand )
        {
    case KVtEngTerminateSession:
        // send mediator command to telephony for call release        
        mediatorSender.EndCall();
        break;
    case KVtEngMuteOutgoingAudio:
    case KVtEngUnmuteOutgoingAudio:
        // notify telephony subsystems about new microphone state
        mediatorSender.NotifyOutgoingAudioState( 
            iCommand == KVtEngUnmuteOutgoingAudio );
        break;   
    default:
        break;
    }
#ifdef VTDEBUG
    TRAPD( err, iObserver.CommandCompleteL( iCommand, aResult ) );
    __VTPRINT2( DEBUG_GEN, "EngOp.Complete err=", err )
#else
    TRAP_IGNORE( iObserver.CommandCompleteL( iCommand, aResult ) );
#endif // VTDEBUG
    if ( iDelete )
        {
        delete this;
        }
    __VTPRINTEXITR( "EngOp.HandleOpComplete %d", aResult )
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::ASyncHandleOpComplete
// Destructor
//
// -----------------------------------------------------------------------------
//
TInt CVtEngOperation::ASyncHandleOpComplete( TAny* aPtr )
    {
    __VTPRINTENTER( "EngOp.ASyncHandleOpComplete" )
    CVtEngOperation* self = reinterpret_cast< CVtEngOperation* >( aPtr );
    TInt error( self->iAsyncErr );
    self->iAsyncErr = KErrNone;
    self->HandleOpComplete( error );
    __VTPRINTEXIT( "EngOp.ASyncHandleOpComplete" )
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::ExecuteL
// Destructor
//
// -----------------------------------------------------------------------------
//
TBool CVtEngOperation::ExecuteL( TDesC8* aParams )
    {
    __VTPRINTENTER( "EngOp.ExecuteL" )
    TBool complete( EFalse );
        
    // Offer for synchronous handling.
    TRAPD( err, complete = OfferExecuteSyncL( aParams ) );
#ifdef VTDEBUG
    if ( err < KErrNone )
        {
        __VTPRINT2( DEBUG_GEN, "EngOp.ExecuteL LEAVE = %d", err )
        }
#endif
    User::LeaveIfError( err );
    if ( !complete )
        {
        // async request
        switch ( iCommand )
            {
            case KVtEngResetEngine:
            case KVtEngInitializeEngine:
            case KVtEngInitializeEngineTest:
            case KVtEngInitializeEngineDiag:
            case KVtEngTerminateSession:
            case KVtEngSwitchToVoice:
                TVtEngEngineInitUtil::HandleL( *this, iHandlers );
                break;

            case KVtEngSetSource:
            case KVtEngPrepareCamera:
            case KVtEngStartViewFinder:
            case KVtEngPauseViewFinder:
            case KVtEngStopViewFinder:
            case KVtEngStartRenderRemote:
            case KVtEngStopRenderRemote:
            case KVtEngHandleLayoutChange:
            case KVtEngUnfreeze:

            // Media object sharing
            case KVtEngStopShareImage:
                TVtEngRenderUtil::HandleL( *this, iHandlers );
                break;

            // Media object sharing
            // These two commands must be trapped and completed without leave
            // because Application UI has to be able to act according to error.
            case KVtEngInitializeShareImage:
            case KVtEngStartShareImage:
                TRAP( err, TVtEngRenderUtil::HandleL( *this, iHandlers ) );
                break;

            case KVtEngSetAudioRouting:
                TVtEngAudioRoutingUtil::HandleL( *this );
                break;

            case KVtEngSetAudioVolume:
            case KVtEngMuteOutgoingAudio:
            case KVtEngUnmuteOutgoingAudio:
                TVtEngAudioPlaybackUtil::HandleL( *this, iHandlers );
                break;
            default:
                __VTPRINT( DEBUG_GEN, "EngOp.ExecuteL not handled" )
                break;
            }

        iObserver.SetOperation( this );

        if ( err != KErrNone )
            {
            __VTPRINT2( DEBUG_GEN, "EngOp.ExecuteL completing command %d", err )
            iAsyncErr = err;
            iAsyncCallback->CallBack();
            }
        }
    else if ( iDelete )
        {
        delete this;
        }
    __VTPRINTEXITR( "EngOp.ExecuteL %d", complete )
    return complete;
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::Cancel
// Cancels operation.
//
// -----------------------------------------------------------------------------
//
TBool CVtEngOperation::Cancel()
    {
    __VTPRINTENTER( "EngOp.Cancel")
    __VTPRINT2( DEBUG_GEN, "Command id = %d", iCommand)
    switch ( iCommand )
        {
        case KVtEngInitializeEngine:
            //TVtEngEngineInitUtil::Cancel( *this );
            break;
        case KVtEngInitializeShareImage:
            TVtEngRenderUtil::Cancel( *this ,iHandlers);
            break;
        default:
            break;
        }
    __VTPRINTEXIT( "EngOp.Cancel" )
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CVtEngOperation::OfferExecuteSyncL
//
//
// -----------------------------------------------------------------------------
//
TBool CVtEngOperation::OfferExecuteSyncL( TDesC8* aParams )
    {
    __VTPRINTENTER( "EngOp.OfferExecuteSyncL" )
    TBool complete( EFalse );
    iParams = aParams; // reset back to null in ExecuteL
    // test

    switch ( iCommand )
        {
        case KVtEngIncreaseAudioVolume:
        case KVtEngDecreaseAudioVolume:
            TVtEngAudioPlaybackUtil::HandleL( *this, iHandlers );
            complete = ETrue;
            break;
        case KVtEngPrepareViewFinder:
        case KVtEngPrepareViewFinderDSA:
        case KVtEngPrepareViewFinderDP:
        case KVtEngStartViewFinder:
        case KVtEngPauseViewFinder:
        case KVtEngStopViewFinder:
        case KVtEngPrepareRemoteRenderDSA:
        case KVtEngPrepareRemoteRenderDP:
        case KVtEngPrepareRemoteRenderNGA:
        case KVtEngStartRenderRemote:
        case KVtEngStopRenderRemote:
        case KVtEngPauseRenderRemote:
        case KVtEngSetZoomStep:
        case KVtEngFreeze:
            TVtEngViewFinderConfigureUtil::HandleL( *this, iHandlers );
            complete = ETrue;
            break;
        case KVtEngPrepareRemoteRender:
            break;
        case KVtEngStartDtmfTone:
        case KVtEngStopDtmfTone:
            // Handling of different UIIs, support is there
        case KVtEngSetUIIDtmfSupport:
        case KVtEngSetUIIBasicStringSupport:
        case KVtEngSetUIIIA5StringSupport:
        case KVtEngSetUIIGeneralStringSupport:

             TVtEngMediaTransportUtil::HandleL( *this, iHandlers );
             complete = ETrue;
            break;

        case KVtEngSetUIForeground:
        case KVtEngSetVideoQuality:
        case KVtEngRequestLastRemoteFrame:
            TVtEngRenderUtil::HandleL( *this, iHandlers );
            complete = ETrue;
            break;

            // Extension commands
        case KVtEngSetContrast:
        case KVtEngSetBrightness:
        case KVtEngSetWhiteBalance:
        case KVtEngSetColorTone:
#if defined ( RD_VT_RTF )
        case KVtEngStartRecord:
        case KVtEngStopRecord:
#endif
            TVtEngExtensionUtil::HandleL( *this );
            complete = ETrue;
            break;

        default:
            __VTPRINT( DEBUG_GEN, "EngOp.ExecuteL not handled sync" )
            break;
        }
    __VTPRINTEXITR( "EngOp.OfferExecuteSyncL %d", complete )
    return complete;
    }

//  End of File