/*
* 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 event listener implementation
*
*/



// INCLUDE FILES
#include    "cvtengmdtrmessagelistener.h"
#include    "VtEngUtils.h"
#include    "CVtEngSettings.h"
#include    "CVtEngEventManager.h"
#include    "cvtengmediatorservice.h"

#include    <cvtlogger.h>
#include    <videotelcontrolmediatorapi.h>
#include    <MediatorCommandResponder.h>
#include    <MediatorDomainUIDs.h>
#include    <mediatoreventsfromtelephonyapi.h>
#include    <vtinternalmediatorapi.h>

// CONSTANTS

// mediator command timeout
static const TInt KVtEngMdtrCmdTimeout = 500000;

// array granularity is 2 (enable mic, disable mic commands)
static const TInt KVtEngMdtrCmdArrayGranularity = 2;

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

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVtEngMdtrMessageListener* CVtEngMdtrMessageListener::NewL(
    CVtEngUtility& aUtils )
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.NewL" )
    CVtEngMdtrMessageListener* self = new( ELeave ) 
        CVtEngMdtrMessageListener( aUtils );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop();
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.NewL" )
    return self;
    }

// Destructor
CVtEngMdtrMessageListener::~CVtEngMdtrMessageListener()
    {
    // ignore error in unregistering
    if ( iMediatorResponder )
        {
        iMediatorResponder->UnregisterCommand( 
                KMediatorVideoTelephonyDomain,
                KCatPhoneToVideotelCommands,
                iCommandList );
        iCommandList.Close();
        iMediatorResponder->UnregisterCommand(
                KMediatorVideoTelephonyDomain,
                KCatVideotelInternalCommands,
                EVtMediatorReleaseDataport );
                
        delete iMediatorResponder;
        }
    
             
    // ignore error in unregistering
    if ( iMediatorEvents )
        {
        iMediatorEvents->UnsubscribeEvent( KMediatorVideoTelephonyDomain,
                KCatVideotelInternalEvents,
                EVtMediatorEventVideoCallInformation );
        delete iMediatorEvents;
        }
    
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::MediatorCommandL
// Receives mediator command and passes it to service object
// -----------------------------------------------------------------------------
//
void CVtEngMdtrMessageListener::MediatorCommandL( 
    TUid /*aDomain*/,
    TUid aCategory, 
    TInt aCommandId, 
    TVersion /*aVersion*/,
    const TDesC8& /*aData*/ )
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.MediatorCommandL" )
    // service object destroys itself after sending command response
    CVtEngMediatorService::StartLD( *iMediatorResponder, iUtils, aCategory, aCommandId );    
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.MediatorCommandL" )
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::CancelMediatorCommand
// Cancallation of mediator command. no-op, just returns response.
// -----------------------------------------------------------------------------
//
void CVtEngMdtrMessageListener::CancelMediatorCommand( 
    TUid /*aDomain*/,
    TUid /*aCategory*/, 
    TInt /*aCommandId*/ )
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.CancelMediatorCommand" )
    // No-op    
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.CancelMediatorCommand" )
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrEventListener::MediatorEventL
// Receives mediator event from VT Mediator Plugin. The event
// contains CLI and/or Dataport name.
// -----------------------------------------------------------------------------
//
void CVtEngMdtrMessageListener::MediatorEventL( TUid /*aDomain*/,
    TUid aCategory, 
    TInt aEventId, 
    const TDesC8& aData )
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.MediatorEventL" )
    if  ( aCategory == KCatVideotelInternalEvents && 
        aEventId == EVtMediatorEventVideoCallInformation )
        {        
        TVtMediatorInfoPackage package;
        package.Copy( aData );
        TVtVideoTelephonyCallInformation data = package();
        __VTPRINT2( DEBUG_GEN, " VT call info data validity value=%d", 
            data.iEventDataValidity)
        // if message contains dataport name save it
        CVtEngSettings& settings = iUtils.Settings();
        if ( data.iEventDataValidity & 
            TVtVideoTelephonyCallInformation::EDataportValid )
            {
            //__VTPRINT(DEBUG_GEN, " Dataport is ready")
            settings.SetDataportInfoL( data.iDataport );
            }                                       
        // if message contains CLI info handle it (save and notify if state 
        // allows)
        if ( data.iEventDataValidity & 
            TVtVideoTelephonyCallInformation::EDisplayTextValid )
            {            
            MVtEngSessionInfo::TCLI cli;
            cli.iCallId = data.iCallId;
            cli.iName = data.iDisplayText.Left( cli.iName.MaxLength() );
            cli.iVoiceCallPossible = data.iVoiceCallPossible;
            settings.SetCLI( cli );
            
            // ready == call is answered (allows setting app to foreground)
            if ( IsReadyForCLIEvent() )
                {
                // send event about CLI availability
                CVtEngEventManager::NotifyEvent( KVtEngCLIAvailable );                
                }
            else
                {
                // Wait until connected state is reached (see HandleVtEventL)
                __VTPRINT( DEBUG_GEN, 
                    "CVtEngMdtrMessageListener defer CLI event" )
                iUtils.EventManager().AddObserverL( this );
                }
            }
        }
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.MediatorEventL" )
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::HandleVtEventL
//
// Handles defered CLI event dispatching (to UI). CLI event was defered because
// engine state was not suitable in MediatorEventL which then started observing
// state changes.
// -----------------------------------------------------------------------------
//
void CVtEngMdtrMessageListener::HandleVtEventL( TInt aEvent )
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.HandleVtEventL" )
    if ( aEvent == KVtEngSessionStateChanged &&
         IsReadyForCLIEvent() ) // <- ready == call is answered
        {
        iUtils.EventManager().RemoveObserver( this );
        __VTPRINT( DEBUG_GEN, 
            "CVtEngMdtrMessageListener dispatch defered CLI event" )
        CVtEngEventManager::NotifyEvent( KVtEngCLIAvailable );
        }
    
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.HandleVtEventL" )
    }

        
// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVtEngMdtrMessageListener::ConstructL()
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.ConstructL" )
    
    // for sending command responses
    iMediatorResponder = CMediatorCommandResponder::NewL( this );
    
    // for receiving events from VT Mediator Plugin (dataport/CLI info)
    iMediatorEvents = CMediatorEventConsumer::NewL( this );
    
    TCapabilitySet capSet;
    capSet.SetEmpty();
    // for audio control
    capSet.AddCapability( ECapabilityWriteDeviceData ); 
    
    // define common attributes for all commands that engine is responsible for
    MediatorService::TCommand command;
    command.iCaps = capSet;
    command.iVersion = TVersion( 
        KPhoneToVideotelCmdVersionMajor, 
        KPhoneToVideotelCmdVersionMinor,
        KPhoneToVideotelCmdVersionBuild );
    command.iTimeout = KVtEngMdtrCmdTimeout;
    
    // enable microphone command
    command.iCommandId = EVtCmdUnmute;
    iCommandList.Append( command );
    
    // disable microphone command
    command.iCommandId = EVtCmdMute;
    iCommandList.Append( command );
        
    // register VT events that are raised by VT Mediator Plugin. 
    // !!! Note !!!!
    // event subscription must be done before command registration because
    // command registration triggers raising the event in the plugin. Different 
    // order would cause the engine to miss the event.
    const TVersion commandVersion( 
            KVideotelMdtrCommandsVersionMajor,
            KVideotelMdtrCommandsVersionMinor,
            KVideotelMdtrCommandsVersionBuild );
    //capSet.SetEmpty();
    //capSet.AddCapability( ECapabilityPowerMgmt );
        
    iMediatorResponder->RegisterCommand( 
                KMediatorVideoTelephonyDomain,
                KCatVideotelInternalCommands,
                EVtMediatorReleaseDataport,
                commandVersion,
                capSet,
                KVtEngMdtrCmdTimeout );
    
    const TVersion eventVersion( 
                KTelephonyEventsVersionMajor,
                KTelephonyEventsVersionMinor,
                KTelephonyEventsVersionBuild );
    
    TInt res = iMediatorEvents->SubscribeEvent( KMediatorVideoTelephonyDomain,
            KCatVideotelInternalEvents,
            EVtMediatorEventVideoCallInformation, 
            eventVersion );
    
    if ( res == KErrNone )
        {
        // register Mediator commands that we handle
        res = iMediatorResponder->RegisterCommand( 
            KMediatorVideoTelephonyDomain,
            KCatPhoneToVideotelCommands,
            iCommandList );
        
        }
    __VTPRINTEXITR( "CVtEngMdtrMessageListener.ConstructL res=%d",res )
    // registering must not fail
    User::LeaveIfError( res );
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::CVtEngMdtrMessageListener
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtEngMdtrMessageListener::CVtEngMdtrMessageListener( CVtEngUtility& aUtils)
 : iUtils( aUtils ), iCommandList( KVtEngMdtrCmdArrayGranularity )
    {    
    __VTPRINTENTER( "CVtEngMdtrMessageListener.CVtEngMdtrMessageListener" )
    __VTPRINTEXIT( "CVtEngMdtrMessageListener.CVtEngMdtrMessageListener" )
    }

// -----------------------------------------------------------------------------
// CVtEngMdtrMessageListener::IsReadyForCLIEvent
// Checks if engine state is appropriate to send CLI event.
// -----------------------------------------------------------------------------
//
TBool CVtEngMdtrMessageListener::IsReadyForCLIEvent() const
    {
    __VTPRINTENTER( "CVtEngMdtrMessageListener.IsReadyForCLIEvent" )
    const MVtEngSessionInfo::TSessionState state = 
        iUtils.StateManager()->SessionState();
    const TBool isReady =
       ( state == MVtEngSessionInfo::EConnected || 
         state == MVtEngSessionInfo::ENegotiating ||
         state == MVtEngSessionInfo::EOpen );    
    __VTPRINTEXITR( "CVtEngMdtrMessageListener.IsReadyForCLIEvent %d>", 
        isReady )
    return isReady;
    }

//  End of File