/*

* Copyright (c) 2005-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 CPhoneConference class.

*

*/

// INCLUDES

#include <ScreensaverInternalPSKeys.h>

#include <eikmenub.h> 

#include <eikenv.h>

#include <StringLoader.h>

#include <pevirtualengine.h>

#include <mpeengineinfo.h>

#include <cpephonemodelif.h>

#include <featmgr.h>

#include "cphoneconference.h"

#include "mphonestatemachine.h"

#include "phoneviewcommanddefinitions.h"

#include "phoneui.hrh"

#include "cphonemainresourceresolver.h"

#include "phonerssbase.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamcallheaderdata.h"

#include "tphonecmdparamkeyevent.h"

#include "phonestatedefinitions.h"

#include "tphonecmdparamglobalnote.h"

#include "phonestatedefinitionsgsm.h"

#include "tphonecmdparamcallstatedata.h"

#include "cphonekeys.h"

#include "phonelogger.h"

#include "cphonepubsubproxy.h"

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CPhoneConference::CPhoneConference( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization ) : 

    CPhoneGsmInCall( aStateMachine, aViewCommandHandle, aPhoneCustomization )

    {

    }

// -----------------------------------------------------------

// CPhoneConference::~CPhoneConference()

// Destructor

// (other items were commented in a header).

// -----------------------------------------------------------

//

CPhoneConference::~CPhoneConference()

    {

    }

// -----------------------------------------------------------

// CPhoneConference::ConstructL()

// Constructor

// (other items were commented in a header).

// -----------------------------------------------------------

//

void CPhoneConference::ConstructL()

    {

    CPhoneGsmInCall::ConstructL();

    // Re-enable global notes

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    CPhonePubSubProxy::Instance()->ChangePropertyValue(

                    KPSUidScreenSaver,

                    KScreenSaverAllowScreenSaver,

                    EPhoneScreensaverAllowed ); 

    DefineAndSetHoldFlagL();

    }

// -----------------------------------------------------------

// CPhoneConference::NewL()

// Constructor

// (other items were commented in a header).

// -----------------------------------------------------------

//

CPhoneConference* CPhoneConference::NewL( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization )

    {

    CPhoneConference* self = new( ELeave ) CPhoneConference( 

        aStateMachine, aViewCommandHandle, aPhoneCustomization );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------

// CPhoneConference::HandlePhoneEngineMessageL

// -----------------------------------------------------------

//

void CPhoneConference::HandlePhoneEngineMessageL( 

    const TInt aMessage, 

    TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandlePhoneEngineMessageL()");

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageIdle:

            HandleIdleL( aCallId );

            break;

        case MEngineMonitor::EPEMessageConferenceIdle:

            HandleConferenceIdleL();

            break;

        case MEngineMonitor::EPEMessageHeldConference:

            HandleHeldConferenceL( aCallId );

            break;

        case MEngineMonitor::EPEMessageConnectedConference:

            HandleConnectedConferenceL();

            break;

        case MEngineMonitor::EPEMessageAddedConferenceMember:

            UpdateConferenceSecurityStatusL( aCallId );

            break;

        case MEngineMonitor::EPEMessageWentOneToOne:

            HandleWentOneToOneL( aCallId );

            break;

        case MEngineMonitor::EPEMessageHeld:

            {

            TPhoneCmdParamCallHeaderData callHeaderParam;

            callHeaderParam.SetCallState( EPEStateHeld );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId, 

                &callHeaderParam );

            }

            break;

        case MEngineMonitor::EPEMessageConnected:

            {

            TPhoneCmdParamCallHeaderData callHeaderParam;

            callHeaderParam.SetCallState( EPEStateConnected );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId, 

                &callHeaderParam );

            }

            break;

        case MEngineMonitor::EPEMessageDialing:

            break;

        case MEngineMonitor::EPEMessageIncoming:

            HandleIncomingL( aCallId );

            break;

        default:

            CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        }

    }

// -----------------------------------------------------------

// CPhoneConference:HandleCommandL

// -----------------------------------------------------------

//

TBool CPhoneConference::HandleCommandL( TInt aCommand )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleCommandL()");

    TBool commandStatus = ETrue;

    switch( aCommand )

        {   

        case EAknSoftkeyCancel:

            BeginUiUpdateLC();

            CloseSelectionListL();

            SetTouchPaneButtons( EPhoneConferenceButtons );

            EndUiUpdate();    

            UpdateCbaL( EPhoneCallHandlingInCallCBA );

            break;

        case EPhoneInCallCmdHold:

        case EPhoneInCallCmdConferenceHold:

            iStateMachine->SendPhoneEngineMessage( 

                CPEPhoneModelIF::EPEMessageHoldConference );

            break;

        case EPhoneInCallCmdUnhold:

        case EPhoneInCallCmdConferenceUnhold:

            iStateMachine->SendPhoneEngineMessage( 

                CPEPhoneModelIF::EPEMessageResumeConference );

            break;

        // Conference -> Drop participant

        case EPhoneInCallCmdDropSelection:

            OpenDropParticipantSelectionL();

            break;

        // Drop CBA    

        case EPhoneInCallCmdDrop:

            DropSelectedParticipantL();

            break;

        case EPhoneInCallCmdPrivateSelection:

            OpenPrivateSelectionL();

            break;

        case EPhoneInCallCmdPrivate:

            PrivateSelectedParticipantL();

            break;

        case EPhoneInCallCmdNewCall:

            LaunchNewCallQueryL();

            break;

        case EPhoneInCallCmdNewCallCall:

            CallFromNewCallQueryL();

            break;

        case EPhoneInCallCmdParticipants:

            OpenParticipantsListL();

            break;

        case EPhoneViewOpenNumberEntry:

            if ( IsConferenceBubbleInSelectionMode() )

                {

                CloseSelectionListL();

                SetTouchPaneButtons( EPhoneConferenceButtons );

                }

            commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

            break;            

        default:

            commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

            break;

        }

    return commandStatus;

    }

// -----------------------------------------------------------

// CPhoneConference::UpdateInCallCbaL

// -----------------------------------------------------------

//

void CPhoneConference::UpdateInCallCbaL()

    {

    if ( iViewCommandHandle->HandleCommandL( EPhoneViewIsConferenceInExpandedMode ) 

        != EPhoneViewResponseSuccess )

        {

        UpdateCbaL( EPhoneCallHandlingInCallCBA );

        }    

    }

// -----------------------------------------------------------

// CPhoneConference::OpenMenuBarL

// -----------------------------------------------------------

//

void CPhoneConference::OpenMenuBarL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::OpenMenuBarL()");

    TInt resourceId;

    if ( iOnScreenDialer && IsDTMFEditorVisibleL() )

        {

        resourceId = EPhoneDtmfDialerMenubar;

        }

    else if ( IsNumberEntryVisibleL() )

        {

        resourceId = EPhoneConfCallMenubarWithNumberEntry;

        }

    else if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) 

              && IsConferenceBubbleInSelectionMode() )        

        {

        resourceId = EPhoneConfCallParticipantsMenubar;            

        }

    else

        {

        resourceId = EPhoneConfCallMenubar;

        }

    TPhoneCmdParamInteger integerParam;

    integerParam.SetInteger( 

        CPhoneMainResourceResolver::Instance()->

        ResolveResourceID( resourceId ) );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarOpen, 

        &integerParam );

    }

// -----------------------------------------------------------

// CPhoneConference::HandleKeyEventL

// -----------------------------------------------------------

//

void CPhoneConference::HandleKeyEventL( 

    const TKeyEvent& aKeyEvent, 

    TEventCode aEventCode )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleKeyEventL()");

    if ( IsConferenceBubbleInSelectionMode() )

        {

        if ( aKeyEvent.iCode == EKeyUpArrow ||

             aKeyEvent.iCode == EKeyDownArrow )

            {

            TPhoneCmdParamKeyEvent keyEventParam;

            keyEventParam.SetKeyEvent( aKeyEvent );

            keyEventParam.SetEventCode( aEventCode );    

            iViewCommandHandle->ExecuteCommandL( 

                EPhoneViewMoveHighLightInList, &keyEventParam );

            }

        }

    else

        {

        if ( CPhoneKeys::IsNumericKey( aKeyEvent, aEventCode ) )

            {

            // Handle numeric keys when key events are received 

            // in conference state.

            CPhoneGsmInCall::HandleNumericKeyEventL( aKeyEvent, aEventCode );

            }

        else

            {

            // Handle other key events.

            CPhoneState::HandleKeyEventL( aKeyEvent, aEventCode );

            }

        }

    }

// --------------------------------------------------------------

// CPhoneConference::HandleKeyMessageL

// --------------------------------------------------------------

//

void CPhoneConference::HandleKeyMessageL( 

    TPhoneKeyEventMessages aMessage,

    TKeyCode aCode )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleKeyMessageL()");

    switch ( aCode )

        {

        // send-key

        case EKeyYes:

            if( IsNumberEntryVisibleL() )

                {

                CallFromNumberEntryL();    

                }

            else

                {

                ToggleHoldL();    

                }

            break;

        default:

            // do base operation

            CPhoneGsmInCall::HandleKeyMessageL( aMessage, aCode );

            break;

        }

    }

// -----------------------------------------------------------

// CPhoneConference::HandleNumberEntryClearedL

// -----------------------------------------------------------

//

void CPhoneConference::HandleNumberEntryClearedL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleNumberEntryClearedL()");

    // Update CBA when number entry is cleared

    UpdateInCallCbaL();

    }

// -----------------------------------------------------------

// CPhoneConference:HandleIdleL

// -----------------------------------------------------------

//

void CPhoneConference::HandleIdleL( TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleIdleL()");

    // Re-enable global notes

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    // Stop capturing keys

    CaptureKeysDuringCallNotificationL( EFalse );

    // If dialler is not open then close menu bar.

    if ( !IsNumberEntryUsedL() )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

        }

    // If conference bubble still exists then we have conference and

    // single call

    TPhoneCmdParamBoolean conferenceBubbleExists;

    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsConference, 

        &conferenceBubbleExists ); 

    if( conferenceBubbleExists.Boolean() )

        {

        // Go to Conference And Single state

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewRemoveFromConference, aCallId ); 

        }

    else

        {

        // Remove call header

        iViewCommandHandle->ExecuteCommandL( 

            EPhoneViewRemoveCallHeader, aCallId );    

        }

    }

// -----------------------------------------------------------

// CPhoneConference:HandleConferenceIdleL

// -----------------------------------------------------------

//

void CPhoneConference::HandleConferenceIdleL()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleConferenceIdleL()");

    BeginUiUpdateLC();

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveConferenceBubble );

    TPhoneCmdParamInteger activeCallCount;

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewGetCountOfActiveCalls, &activeCallCount );

    switch( activeCallCount.Integer() )

        {

        case ENoActiveCalls:

            MakeStateTransitionToIdleL();

        case EOneActiveCall:

            {

            // Fetch ringing call's id from view

            TPhoneCmdParamCallStateData callStateData;

            callStateData.SetCallState( EPEStateRinging );

            iViewCommandHandle->HandleCommandL(

                EPhoneViewGetCallIdByState, &callStateData );

            if( callStateData.CallId() > KErrNotFound )

                {            

                CPhonePubSubProxy::Instance()->ChangePropertyValue(

                                KPSUidScreenSaver,

                                KScreenSaverAllowScreenSaver,

                                EPhoneScreensaverNotAllowed );

                UpdateCbaL( EPhoneCallHandlingCallWaitingCBA );

                iStateMachine->ChangeState( EPhoneStateWaitingInSingle );    

                }

            else

                {

                }

            }

            break;

        case ETwoActiveCalls:

            MakeStateTransitionToTwoSinglesL();

            break;

        default:

            MakeStateTransitionToTwoSinglesL();

            break;

        }

    }

// -----------------------------------------------------------

// CPhoneConference::HandleHeldConferenceL

// -----------------------------------------------------------

//

void CPhoneConference::HandleHeldConferenceL( TInt aCallId )

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, 

        "CPhoneConference::HandleHeldConferenceL()");

    TPhoneCmdParamCallHeaderData callHeaderParam;

    callHeaderParam.SetCallState( EPEStateHeld );

    TInt callLabelId;

    TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );

    callLabelId = CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( EPhoneCallOnHold );

    StringLoader::Load( 

        labelText, 

        callLabelId, 

        CCoeEnv::Static() );        

    callHeaderParam.SetLabelText( labelText );

    iViewCommandHandle->ExecuteCommandL( 

        EPhoneViewUpdateBubble, aCallId, &callHeaderParam );

    // Set Hold flag to view

    SetHoldFlagL();

    if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

        {