/*

* 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