/*

* 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