/*
* Copyright (c) 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:  Mediator service implementation
*
*/



// INCLUDE FILES
#include    "cvtengmediatorservice.h"
#include    "cvtenginternaloperation.h"
#include    "CVtEngStateManager.h"
#include    "CVtEngEventManager.h"
#include    "VtEngUtils.h"
#include    "CVtEngSettings.h"
#include    <cvtlogger.h>
#include    <MediatorCommandResponder.h>
#include    <MediatorDomainUIDs.h>
#include    <videotelcontrolmediatorapi.h> 
#include    <videoteltophonecommandsapi.h>
#include    <vtinternalmediatorapi.h>

// CONSTANTS

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

// -----------------------------------------------------------------------------
// CVtEngMediatorService::StartLD
// Mediator service starter.
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::StartLD( 
        CMediatorCommandResponder& aResponder,
        CVtEngUtility& aUtils,
        const TUid aCategory,
        const TInt aCommand )
    {
    __VTPRINTENTER( "CVtEngMediatorService.StartLD" )
    CVtEngMediatorService* self = new ( ELeave ) CVtEngMediatorService(
        aResponder, aUtils, aCategory, aCommand );
    CleanupStack::PushL( self );
    self->ConstructAndDoServiceL();
    CleanupStack::Pop();
    __VTPRINTEXIT( "CVtEngMediatorService.StartLD" )
    }
    
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CVtEngMediatorService::~CVtEngMediatorService()
    {
    // ensure this is removed
    __VTPRINTENTER( "CVtEngMediatorService::~CVtEngMediatorService" )
    iUtils.EventManager().RemoveObserver( this );
    
    // send response if destructed due to leave in ConstructAndDoServiceL
    SendMediatorResponseD( EFalse );
    __VTPRINTEXIT( "CVtEngMediatorService::~CVtEngMediatorService" )
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::SetOperation
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::SetOperation( CVtEngOperation* /*aActiveOp*/ )
    {
    __VTPRINTENTER( "CVtEngMediatorService.SetOperation" )
    // no-op
    __VTPRINTEXIT( "CVtEngMediatorService.SetOperation" )
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::CommandCompleteL
// callback to internal operation.
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::CommandCompleteL(
    const TVtEngCommandId /*aCommand*/,
    const TInt aResult )
    {
    __VTPRINTENTER( "CVtEngMediatorService.CommandCompleteL" )

    iServiceStatus = aResult;

    // Sends response to Telephony if not already sent by
    // HandleVtEventL -> SendMediatorResponseD
    SendMediatorResponseD( ETrue );
    __VTPRINTEXITR( "CVtEngMediatorService.CommandCompleteL %d", aResult )
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::HandleVtEventL
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::HandleVtEventL( TInt aEvent )
    {
    __VTPRINTENTER( "CVtEngMediatorService.HandleVtEventL" )
    
    // This is registered event observer when shutdown mediator command was
    // received. Now send response if state precondition is met
    if ( aEvent == KVtEngSessionStateChanged &&
         IsShuttingDown() )
        {
        // no interest on events any more, task fulfilled
        iUtils.EventManager().RemoveObserver( this );
        
        // iServiceStatus used for mediator response
        iServiceStatus = KErrNone;
        
        SendMediatorResponseD( EFalse );
        }
    __VTPRINTEXIT( "CVtEngMediatorService.HandleVtEventL" )
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::CVtEngMediatorService
// -----------------------------------------------------------------------------
//
CVtEngMediatorService::CVtEngMediatorService( 
    CMediatorCommandResponder& aResponder, 
    CVtEngUtility& aUtils,
    const TUid aCategory,
    const TInt aCommandId ) :
    iResponder( aResponder ), 
    iUtils( aUtils ),
    iCategory( aCategory ),
    iCommandId( aCommandId ),
    iServiceStatus( KErrNotReady )
    {
    __VTPRINTENTER( "CVtEngMediatorService.CVtEngMediatorService" )
    __VTPRINTEXIT( "CVtEngMediatorService.CVtEngMediatorService" )
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::ConstructAndDoServiceL
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::ConstructAndDoServiceL()
    {
    __VTPRINTENTER( "CVtEngMediatorService.ConstructAndDoServiceL" )
    __VTPRINT2( DEBUG_GEN, " CVtEngMediatorService.ConstructAndDoServiceL command id=%d", iCommandId )
    // if starting of any operation below fails (StartOperationL leaves),
    // this object is deleted. Destructor sends mediator response.
    // non-supported command leads to leave+destructor also (see default case)
    if ( KCatVideotelInternalCommands == iCategory)
        {
        switch ( iCommandId )
            {
            case EVtMediatorReleaseDataport:
                if ( !IsShuttingDown()  )
                    {
                    // Mediator response is sent when state becomes appropriate, 
                    // indicated by call to HandleVtEventL, or
                    // when operation callback CommandCompleteL is called,
                    // which ever comes first. However, this object is deleted
                    // only after operation callback is received.
                    iUtils.EventManager().AddObserverL( this );
                    StartOperationL( KVtEngTerminateSession );
                    }     
                // if already shutting down this is no op (and self destructed)
                // if get this command because endactivecall from vt menu, do not do any op from here
                else 
                    {
                    SendMediatorResponseD(EFalse);
                    }
                break;
            default:
                // requested command that is not supported, issue "failed" response
                iServiceStatus = KErrNotSupported;            
                break;
            }
        }
    else
        {
        switch ( iCommandId )
            {
            case EVtCmdUnmute:
            case EVtCmdMute:
                {
                TVtEngCommandId engineCmd = ( iCommandId == 
                    EVtCmdUnmute ) ? KVtEngUnmuteOutgoingAudio : 
                    KVtEngMuteOutgoingAudio;
                if ( !IsShuttingDown()  )
                    {
                    StartOperationL( engineCmd );
                    }
                else
                    {
                    SendMediatorResponseD(EFalse);
                    }
                }
                break;
            default:
                // requested command that is not supported, issue "failed" response
                iServiceStatus = KErrNotSupported;            
                break;
            }     
        }
    if ( iServiceStatus != KRequestPending && !IsShuttingDown() )
        { // results in destruction of this object and sending of mediator 
          // response with error
        //__VTPRINT2( DEBUG_GEN, "CVtEngMediatorService.ConstructAndDoServiceL leave by iServiceStatus: %d", iServiceStatus )
        User::Leave( iServiceStatus );
        }
     
    __VTPRINTEXIT( "CVtEngMediatorService.ConstructAndDoServiceL" )
    }
// -----------------------------------------------------------------------------
// CVtEngMediatorService::IsShuttingDown
// Checks if shutdown is ongoing
// -----------------------------------------------------------------------------
//
TBool CVtEngMediatorService::IsShuttingDown() const
    {
    __VTPRINTENTER( "CVtEngMediatorService.IsShuttingDown" )
    const MVtEngSessionInfo::TSessionState state = 
        iUtils.StateManager()->SessionState();
    TBool isShuttingDown = EFalse;
    
    // consider shutdown true if clearing or idle
    if ( state == MVtEngSessionInfo::EClearing || 
         state == MVtEngSessionInfo::EIdle )
        {
        isShuttingDown = ETrue;            
        }
    __VTPRINTEXITR( "CVtEngMediatorService.IsShuttingDown %d",
        isShuttingDown )
    return isShuttingDown;
    }

// -----------------------------------------------------------------------------
// CVtEngMediatorService::StartOperationL
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::StartOperationL( const TVtEngCommandId aCommand )
    {
    __VTPRINTENTER( "CVtEngMediatorService.StartOperationL" )
    iOperation = CVtEngInternalOperation::NewL( 
        aCommand,
        iUtils.StateManager()->Handlers(),
        *this );        
    iOperation->ExecuteL();
    iServiceStatus = KRequestPending;
    __VTPRINTEXIT( "CVtEngMediatorService.StartOperationL" )
    }
        
// -----------------------------------------------------------------------------
// CVtEngMediatorService::SendMediatorResponseD
// -----------------------------------------------------------------------------
//
void CVtEngMediatorService::SendMediatorResponseD( const TBool aDeleteThis )
    {
    __VTPRINTENTER( "CVtEngMediatorService.SendMediatorResponseD" )
    __VTPRINT2( DEBUG_GEN, "CVtEngMediatorService.SendMediatorResponseD command: %d", iCommandId )
    if ( iCommandId != KErrNotFound )
        {
        if ( iCategory == KCatVideotelInternalCommands && iCommandId == EVtMediatorReleaseDataport )
            {
            iResponder.IssueResponse(
                KMediatorVideoTelephonyDomain,
                KCatVideotelInternalCommands,
                iCommandId,
                iServiceStatus,
                KNullDesC8() );
              }
        else
            {
            iResponder.IssueResponse(
                KMediatorVideoTelephonyDomain,
                KCatPhoneToVideotelCommands,
                iCommandId,
                iServiceStatus,
                KNullDesC8() );
            }
            
        // prevents further response because destructor also calls this method
        iCommandId = KErrNotFound;
        }
    if ( aDeleteThis )
        {
        // note! check above is mandatory because this method is called
        // also from destructor.
        delete this;
        }
    __VTPRINTEXIT( "CVtEngMediatorService.SendMediatorResponseD" )
    }
        
//  End of File