/*
* 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: Implementation of CPhoneMediatorCommandListener class.
*
*/


// INCLUDE FILES
#include <MediatorDomainUIDs.h>
#include "mphonemenuandcbaevents.h"
#include "mphonekeyeventhandler.h"
#include "mphoneviewcommandhandle.h"
#include "cphonemediatorcommandlistener.h"
#include "phonelogger.h"
#include "phonemediatorpackagetypes.h"
#include "cphonestatehandle.h"
#include "tphonecmdparamboolean.h"
#include "videoteltophonecommandsapi.h"
#include "mediatoraudiocommandstotelephonyapi.h"
#include "phoneui.pan"
#include "phoneui.hrh"
#include "pevirtualengine.h"
#include "mpeengineinfo.h"
#include "mediatorcommandstotelephonyapi.h"
#include "cphonereconnectquery.h"

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

// ---------------------------------------------------------
// CPhoneMediatorCommandListener::Instance
// Initializes the singleton object
// (other items were commented in a header).
// ---------------------------------------------------------
//
CPhoneMediatorCommandListener* CPhoneMediatorCommandListener::Instance()
    {
    CPhoneMediatorCommandListener* instance = static_cast<CPhoneMediatorCommandListener*> 
        ( CCoeEnv::Static ( KUidMediatorCommandListenerSingleton ) );
    
    if ( !instance )
        {
        TRAPD( err, instance = CPhoneMediatorCommandListener::NewL() );
        if ( err )
	        {
	        Panic( EPhoneUtilsCouldNotCreateSingleton );	
	        }
        }
    return instance;
    }

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::CPhoneMediatorCommandListener
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPhoneMediatorCommandListener::CPhoneMediatorCommandListener() :
    CCoeStatic( KUidMediatorCommandListenerSingleton )
    {
    }

// Destructor
CPhoneMediatorCommandListener::~CPhoneMediatorCommandListener()
    {
    if ( iCommandResponder )
    	{
    	iCommandResponder->UnregisterCommand( KMediatorTelephonyDomain, 
                                              KCatVideoTelToPhoneCommands, 
                                              iVideoTelCommands );

    	iCommandResponder->UnregisterCommand( KMediatorTelephonyDomain, 
                                              KCatAudioCommandsToTelephony, 
                                              iAudioCommands );

    	iCommandResponder->UnregisterCommand( KMediatorTelephonyDomain, 
                                              KCatCommandsToTelephony, 
                                              iGenericCommands );

        delete iCommandResponder;
        iCommandResponder = NULL;
    	}
    iVideoTelCommands.Close();
	iAudioCommands.Close();
	iGenericCommands.Close();
    }

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::ConstructL()
    {
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, "CPhoneMediatorCommandListener::ConstructL( ) ");

	RegisterMediatorCommandsL();
    }

// -----------------------------------------------------------
// CPhoneMediatorCommandListener::NewL()
// Constructor
// (other items were commented in a header).
// -----------------------------------------------------------
//
CPhoneMediatorCommandListener* CPhoneMediatorCommandListener::NewL()
    {
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, "CPhoneMediatorCommandListener::NewL( ) ");
    CPhoneMediatorCommandListener* self = new( ELeave ) CPhoneMediatorCommandListener();
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    return self;
    }

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::Initialize
// -----------------------------------------------------------------------------
//    
void CPhoneMediatorCommandListener::Initialize( 
	MPhoneMenuAndCbaEvents* aMenuAndCbaEventHandler,
	MPhoneEngineMessageSender* aMessageSender,
	MPEEngineInfo* aEngineInfo )
	{
	__LOGMETHODSTARTEND(EPhoneMediatorCenter, "CPhoneMediatorCommandListener::Initialize( ) ");
	iMenuAndCbaHandler = aMenuAndCbaEventHandler;
	iMessageSender = aMessageSender;
	iEngineInfo = aEngineInfo;
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::RegisterMediatorCommandsL
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::RegisterMediatorCommandsL()
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::RegisterMediatorCommandsL( ) ");
	iCommandResponder = CMediatorCommandResponder::NewL( this );

    RegisterVideoTelephonyMediatorCommands();
    RegisterAudioMediatorCommands();
    RegisterGenericMediatorCommands();                                                
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::RegisterVideoTelephonyMediatorCommands
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::RegisterVideoTelephonyMediatorCommands()
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::RegisterVideoTelephonyMediatorCommands( ) ");
    TCapabilitySet caps;
    caps.SetEmpty();

    // Video Telephony Commands
    MediatorService::TCommand newCommand;
    newCommand.iCommandId = EVtCmdFallback;
    newCommand.iVersion = TVersion( KVideoTelToPhoneCmdVersionMajor, 
    	KVideoTelToPhoneCmdVersionMinor, KVideoTelToPhoneCmdVersionBuild );
    caps.Set( ECapabilityNetworkControl );
    newCommand.iCaps = caps;
    newCommand.iTimeout = KPhoneUiMediatorIfTimeout;    
    iVideoTelCommands.Append( newCommand );

    newCommand.iCommandId = EVtCmdSwitchToVoice;
    iVideoTelCommands.Append( newCommand );
    
    newCommand.iCommandId = EVtCmdLowMemory;
    iVideoTelCommands.Append( newCommand );

    // Register Video Telephony Commands
    TInt error = iCommandResponder->RegisterCommand( KMediatorTelephonyDomain, 
                                                     KCatVideoTelToPhoneCommands, 
                                                     iVideoTelCommands );
	__ASSERT_DEBUG( error == KErrNone, Panic( EPhoneMediatorCenterRegistrationFailed ) );
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::RegisterAudioMediatorCommands
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::RegisterAudioMediatorCommands()
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::RegisterAudioMediatorCommands( ) ");
    TCapabilitySet caps;
    caps.SetEmpty();

    // Audio Commands
    MediatorService::TCommand newCommand;
    newCommand.iCommandId = EAudioCmdUnmute;
    newCommand.iVersion = TVersion( KAudioCmdToTelephonyVersionMajor, 
    	KAudioCmdToTelephonyVersionMinor, KAudioCmdToTelephonyVersionBuild );
    caps.Set( ECapabilityNetworkControl );
    newCommand.iCaps = caps;
    newCommand.iTimeout = KPhoneUiMediatorIfTimeout;    
    iAudioCommands.Append( newCommand );

    newCommand.iCommandId = EAudioCmdMute;
    iAudioCommands.Append( newCommand );

    // Register Audio Commands
    TInt error = iCommandResponder->RegisterCommand( KMediatorTelephonyDomain, 
                                                     KCatAudioCommandsToTelephony, 
                                                     iAudioCommands );
	__ASSERT_DEBUG( error == KErrNone, Panic( EPhoneMediatorCenterRegistrationFailed ) );
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::RegisterGenericMediatorCommands
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::RegisterGenericMediatorCommands()
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::RegisterGenericMediatorCommands( ) ");
    TCapabilitySet caps;
    caps.SetEmpty();

    // Generic Commands
    MediatorService::TCommand newCommand;
    newCommand.iCommandId = EPhoneCmdEndActiveCall;
    newCommand.iVersion = TVersion( KTelephonyCommandsVersionMajor, 
    	KTelephonyCommandsVersionMinor, KTelephonyCommandsVersionBuild );
    caps.Set( ECapabilityNetworkControl );
    newCommand.iCaps = caps;
    newCommand.iTimeout = KPhoneUiMediatorIfTimeout;    
    iGenericCommands.Append( newCommand );

    // Register Generic Commands
    TInt error = iCommandResponder->RegisterCommand( KMediatorTelephonyDomain, 
                                                     KCatCommandsToTelephony, 
                                                     iGenericCommands );
	__ASSERT_DEBUG( error == KErrNone, Panic( EPhoneMediatorCenterRegistrationFailed ) );
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::MediatorCommandL
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::MediatorCommandL( 
	TUid aDomain, 
	TUid aCategory, 
    TInt aCommandId, 
    TVersion aVersion, 
    const TDesC8& /*aData*/ )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, "CPhoneMediatorCommandListener::MediatorCommandL( ) ");
	if( aDomain == KMediatorTelephonyDomain &&
	    aCategory == KCatVideoTelToPhoneCommands )
		{
		VideoTelephonyCommandL( aCommandId, aVersion );
		SendResponse( aDomain, aCategory, aCommandId );
		return;			
		}
	else if( aDomain == KMediatorTelephonyDomain &&
             aCategory == KCatAudioCommandsToTelephony )
		{
		AudioCommandL( aCommandId, aVersion );
		SendResponse( aDomain, aCategory, aCommandId );
		return;
		}
	else if( aDomain == KMediatorTelephonyDomain &&
	         aCategory == KCatCommandsToTelephony )
		{
		GenericCommandL( aCommandId, aVersion );
		SendResponse( aDomain, aCategory, aCommandId );
		return;			
		}
    
	TInt error = iCommandResponder->IssueResponse( aDomain, 
                                                 aCategory, 
                                                 aCommandId,
                                                 KErrNotFound, 
                                                 KNullDesC8 );								
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::CancelMediatorCommand
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::CancelMediatorCommand( 
	TUid /*aDomain*/,
    TUid /*aCategory*/, 
    TInt /*aCommandId*/ )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::CancelMediatorCommand( ) ");
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::SendResponse
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::SendResponse( 
	TUid aDomain, 
	TUid aCategory, 
    TInt aCommandId )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::SendResponse( ) ");
	iCommandResponder->IssueResponse( aDomain, 
                                      aCategory, 
                                      aCommandId,
                                      KErrNone, 
                                      KNullDesC8 );		
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::VideoTelephonyCommandL
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::VideoTelephonyCommandL( TInt aCommandId, TVersion /*aVersion*/ )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::VideoTelephonyCommandL( ) ");
        
    __ASSERT_DEBUG( iMenuAndCbaHandler, Panic( EPhoneMediatorCenterSingletonNotInitialized ) );
    __ASSERT_DEBUG( iMessageSender, Panic( EPhoneMediatorCenterSingletonNotInitialized ) );
    
	switch( aCommandId )
		{
		case EVtCmdFallback:
		    iMenuAndCbaHandler->HandleCommandL( EPhoneInCallCmdEndThisActiveCall );
		    CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
		    break;
		    
		case EVtCmdSwitchToVoice:
		    iMenuAndCbaHandler->HandleCommandL( EPhoneCmdYesSwitchToVoice );
			break;
			
		case EVtCmdLowMemory:
		    iMenuAndCbaHandler->HandleCommandL( EPhoneCmdVideoCallOutOfMemory );
		    break;
			
		default:
			__ASSERT_DEBUG( false, Panic( EPhoneMediatorCenterInvalidCommand ) );
			break;
		}		
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::AudioCommandL
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::AudioCommandL( TInt aCommandId, TVersion /*aVersion*/ )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::AudioCommandL( ) ");

    __ASSERT_DEBUG( iMessageSender, Panic( EPhoneMediatorCenterSingletonNotInitialized ) );
    __ASSERT_DEBUG( iEngineInfo, Panic( EPhoneMediatorCenterSingletonNotInitialized ) );
		
	switch( aCommandId )
		{
		case EAudioCmdUnmute:
			iEngineInfo->SetAudioMuteCommand( false );
			iMessageSender->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageSetAudioMute );
			break;
			
		case EAudioCmdMute:
			iEngineInfo->SetAudioMuteCommand( true );
			iMessageSender->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageSetAudioMute );
			break;
			
		default:
			__ASSERT_DEBUG( false, Panic( EPhoneMediatorCenterInvalidCommand ) );
			break;
		}
	}

// -----------------------------------------------------------------------------
// CPhoneMediatorCommandListener::GenericCommandL
// -----------------------------------------------------------------------------
//
void CPhoneMediatorCommandListener::GenericCommandL( TInt aCommandId, TVersion /*aVersion*/ )
	{
    __LOGMETHODSTARTEND(EPhoneMediatorCenter, 
        "CPhoneMediatorCommandListener::GenericCommandL( ) ");
    __ASSERT_DEBUG( iMenuAndCbaHandler, Panic( EPhoneMediatorCenterSingletonNotInitialized ) );

	switch( aCommandId )
		{
		case EPhoneCmdEndActiveCall:
			iMenuAndCbaHandler->HandleCommandL( EPhoneInCallCmdEndThisActiveCall );
			break;
			
		default:
			__ASSERT_DEBUG( false, Panic( EPhoneMediatorCenterInvalidCommand ) );
			break;
		}
	}

// End of File