/*

* Copyright (c) 2006 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:  Primary policy class.

*

*/

#include <featmgr.h>

#include <avkon.hrh>

#include <cvtlogger.h>

#include <videotelui.rsg>

#include <avkon.rsg>

#include "cvtuiprimarycmdpolicy.h"

#include "cvtuicmdvalidationactionbase.h"

#include "cvtuicmdcustomvalidationactionbase.h"

#include "tvtuicmdvalidatorcallback.h"

#include "tvtuistates.h"

#include "videotelui.hrh"

#include "tVtuifeaturevariation.h"

#include "CVtUiAppUi.h"

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

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

// CVtUiPrimaryCmdPolicy::NewL

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

//

CVtUiPrimaryCmdPolicy* CVtUiPrimaryCmdPolicy::NewL(

    const TVtUiStates& aUiStates, const CVtUiAppUi& aAppUi )

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.NewL" )

    CVtUiPrimaryCmdPolicy* self =

        new ( ELeave ) CVtUiPrimaryCmdPolicy( aUiStates, aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    __VTPRINTEXIT( "PrimaryCmdPolicy.NewL" )

    return self;

    }

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

// CVtUiPrimaryCmdPolicy::~CVtUiPrimaryCmdPolicy

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

//

CVtUiPrimaryCmdPolicy::~CVtUiPrimaryCmdPolicy()

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.~" )

    __VTPRINTEXIT( "PrimaryCmdPolicy.~" )

    }

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

// CVtUiPrimaryCmdPolicy::ValidateMenuItemsL

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

//

void CVtUiPrimaryCmdPolicy::ValidateMenuItemsL(

    CVtUiCmdValidationActionBase& aAction, TInt )

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidateMenuItemsL" )

    aAction.ProcessL(

        TVtUiCmdValidatorCallBack< CVtUiPrimaryCmdPolicy >( *this,

            ValidateMenuCommand ) );

    __VTPRINTEXIT( "PrimaryCmdPolicy.ValidateMenuItemsL" )

    }

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

// CVtUiPrimaryCmdPolicy::ValidateSoftkeyItemsL

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

//

void CVtUiPrimaryCmdPolicy::ValidateSoftkeyItemsL(

    CVtUiCmdValidationActionBase& aAction, TInt )

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidateSoftkeyItemsL" )

    aAction.ProcessL(

        TVtUiCmdValidatorCallBack< CVtUiPrimaryCmdPolicy >( *this,

            ValidateSoftkey ) );

    __VTPRINTEXIT( "PrimaryCmdPolicy.ValidateSoftkeyItemsL" )

    }

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

// CVtUiPrimaryCmdPolicy::ValidateSoftkeyItemsL

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

//

void CVtUiPrimaryCmdPolicy::ValidateToolbarItemsL(

    CVtUiCmdValidationActionBase& aAction, TInt )

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidateToolbarItemsL" )

    aAction.ProcessL(

        TVtUiCmdValidatorCallBack< CVtUiPrimaryCmdPolicy >( *this,

            ValidateToolbarCommand ) );

    __VTPRINTEXIT( "PrimaryCmdPolicy.ValidateToolbarItemsL" )

    }

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

// CVtUiPrimaryCmdPolicy::CustomValidationL

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

//

void CVtUiPrimaryCmdPolicy::CustomValidationL(

    CVtUiCmdCustomValidationActionBase& aAction, TInt )

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.CustomValidationL" )

    switch ( aAction.CustomTypeId() )

        {

    // Command state validation

    case EVtUiCmdContextTypeExecution:

        aAction.ProcessL( TVtUiCmdValidatorCallBack< CVtUiPrimaryCmdPolicy >(

            *this, ValidateCommandState ) );

        break;

    default:

        __VTPRINT2( DEBUG_GEN,

            "PrimaryCmdPolicy.CustomValidationL unknown typeId = %d",

            aAction.CustomTypeId() );

        break;

        }

    __VTPRINTEXIT( "PrimaryCmdPolicy.CustomValidationL" )

    }

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

// CVtUiPrimaryCmdPolicy::ValidatesContext

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

//

TBool CVtUiPrimaryCmdPolicy::ValidatesContext(

    const TVtUiCmdContextType& aCtxType ) const

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidatesContext" )

    TBool result( EFalse );

    switch ( aCtxType )

        {

    case EVtUiCmdContextTypeMenu:

    case EVtUiCmdContextTypeSoftkey:

    case EVtUiCmdContextTypeToolbar:

    case EVtUiCmdContextTypeExecution:

        result = ETrue;

        break;

    default:

        break;

        }

    __VTPRINTEXITR( "PrimaryCmdPolicy.ValidatesContext %d", result )

    return result;

    }

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

// CVtUiPrimaryCmdPolicy::CVtUiPrimaryCmdPolicy

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

//

CVtUiPrimaryCmdPolicy::CVtUiPrimaryCmdPolicy( const TVtUiStates& aUiStates,

    const  CVtUiAppUi& aAppUi )

    : CVtUiCmdValidatorBase( EVtUiCmdPolicyPriorityPrimary ),

      iUiStates( aUiStates ), iAppUi( aAppUi )

    {

    }

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

// CVtUiPrimaryCmdPolicy::ConstructL

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

//

void CVtUiPrimaryCmdPolicy::ConstructL()

    {

    TVtUiActiveIdleVariation activeIdleVariation;

    iAIEnabled = activeIdleVariation.IsActiveIdleEnabled();

    }

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

// CVtUiPrimaryCmdPolicy::ValidateMenuCommand

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

//

TBool CVtUiPrimaryCmdPolicy::ValidateMenuCommand( TInt aCommandId ) const

    {

    TBool handled;

    return ValidateCommand( aCommandId, handled );

    }

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

// CVtUiPrimaryCmdPolicy::ValidateSoftkey

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

//

TBool CVtUiPrimaryCmdPolicy::ValidateSoftkey( TInt aResourceId ) const

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidateSoftkey" )

    TBool result( EFalse );

    switch ( aResourceId )

        {

    case R_VIDEOTELUI_SOFTKEYS_EMPTY_ACTIVE_COMMAND:

        result = iUiStates.IsCommandActivating();

        break;

    case R_VIDEOTELUI_SOFTKEYS_EMPTY_DIALEREXIT:

        result = iUiStates.IsDialerActivating();

        break;

    case R_VIDEOTELUI_SOFTKEYS_SHARE_OBJECT_IMAGE:

        result = iUiStates.MediaState().IsSharing();

        break;

    case R_VIDEOTELUI_SOFTKEYS_CAPTURE_VIDEO:

        result = iUiStates.IsCaptureModeOn();

        break;

    case R_VIDEOTELUI_SOFTKEYS_ENABLE_AUDIO:

        result = !iUiStates.AudioState().IsAudio();

        break;

    case R_VIDEOTELUI_SOFTKEYS_ENABLE_VIDEO:

        result = !iUiStates.MediaState().IsVideo() &&

            iUiStates.MediaState().HasCamera() &&

            ( iUiStates.ExecState() == TVtUiStates::EExecStateRunning );

        break;

    case R_VIDEOTELUI_SOFTKEYS_DIALER:

    case R_VIDEOTELUI_SOFTKEYS_BT_HANDSFREE:

    case R_VIDEOTELUI_SOFTKEYS_LOUDSPEAKER:

    case R_VIDEOTELUI_SOFTKEYS_HANDSET_B:

        {

        if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) &&

             ( iUiStates.ExecState() == TVtUiStates::EExecStateRunning ) )

            {

            switch ( aResourceId )

                {

            case R_VIDEOTELUI_SOFTKEYS_DIALER:

                result = ETrue;

                break;

                }

            }

        else

            {

            switch ( aResourceId )

                {

            case R_VIDEOTELUI_SOFTKEYS_BT_HANDSFREE:

                result = iUiStates.AudioState().CanActivateBtHf();

                break;

            case R_VIDEOTELUI_SOFTKEYS_LOUDSPEAKER:

                result = iUiStates.AudioState().CanActivateLoudspeaker();

                break;

            case R_VIDEOTELUI_SOFTKEYS_HANDSET_B:

                result = iUiStates.AudioState().CanDeactivateLoudspeaker();

                break;

                }

            }

        }

        break;

    case R_VIDEOTELUI_SOFTKEYS_END_CALL:

        result = ETrue;

        break;

        }

    __VTPRINTEXITR( "PrimaryCmdPolicy.ValidateSoftkey %d", result )

    return result;

    }

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

// CVtUiPrimaryCmdPolicy::ValidateToolbarCommand

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

//

TBool CVtUiPrimaryCmdPolicy::ValidateToolbarCommand( TInt aCommandId ) const

    {

     __VTPRINTENTER( "PrimaryCmdPolicy.ValidateToolbarCommand" )

    __VTPRINT2( DEBUG_GEN, "cmdId = %d", aCommandId )

    TBool result( ETrue );

    switch( aCommandId )

        {

        case EVtUiCmdZoom:

        case EVtUiCmdShareObjectImage:

        case EVtUiCmdSwapImagesPlaces:

        //case EVtUiCmdSnapshot:

            result = EFalse;

            break;

        default:

            result = ValidateMenuCommand( aCommandId );

            break;

        }

    __VTPRINTEXITR( "PrimaryCmdPolicy.ValidateToolbarCommand %d", result )

    return result;

    }

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

// CVtUiPrimaryCmdPolicy::ValidateCommandState

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

//

TBool CVtUiPrimaryCmdPolicy::ValidateCommandState( TInt aCommandId ) const

    {

     __VTPRINTENTER( "PrimaryCmdPolicy.ValidateCommandState" )

    TBool handled;

    TBool allowed( !ValidateCommand( aCommandId, handled ) );

    if ( !handled )

        {

        switch ( aCommandId )

            {

        case EVtUiCmdCapture:

        case EVtUiCmdCancelCapture:

            allowed = iUiStates.IsCaptureModeOn();

            break;

        case EVtUiCmdStopSharingObjectImage:

            allowed = iUiStates.MediaState().IsSharing() &&

                !iUiStates.MediaState().IsVideoPermanentlyStopped();

            break;

        default:

            allowed = ETrue;

            break;

            }

        }

    __VTPRINTEXITR( "PrimaryCmdPolicy.ValidateCommandState %d", allowed )

    return allowed;

    }

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

// CVtUiPrimaryCmdPolicy::ValidateCommand

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

//

TBool CVtUiPrimaryCmdPolicy::ValidateCommand( TInt aCommandId,

    TBool& aHandled ) const

    {

    __VTPRINTENTER( "PrimaryCmdPolicy.ValidateCommand" )

    __VTPRINT2( DEBUG_GEN, "    cmdId = %d", aCommandId )

    TBool result( ETrue );

    aHandled = ETrue;

    const TVtUiMediaState& mediaState( iUiStates.MediaState() );

    const TVtUiAudioState& audioState( iUiStates.AudioState() );

    const TBool disabledVideo( !mediaState.IsVideo() ||

        mediaState.IsSharing() );

    const TBool disabledAudio( !audioState.IsAudio() );

    const TBool disableVideoOptions( !mediaState.HasCamera() );

    const TBool freezeSupported( mediaState.IsFreezeSupported() );

    const TBool frozen( mediaState.IsFrozen() );

    const TBool videoPermStopped( mediaState.IsVideoPermanentlyStopped() );

    const TBool audioPermStopped( audioState.IsAudioPermanentlyStopped() );

    switch( aCommandId )

        {

    case EVtUiCmdSnapshot:

        result = ( disabledVideo && !frozen ) ||

                   disableVideoOptions ||

                   !freezeSupported;

        break;

    case EVtUiCmdUsePrimaryCamera:

        result = mediaState.IsPrimaryCameraInUse() || frozen ||

            !mediaState.HasPrimaryCamera() || mediaState.IsSharing() ||

            videoPermStopped;

        break;

    case EVtUiCmdUseSecondaryCamera:

        result = mediaState.IsSecondaryCameraInUse() || frozen ||

            !mediaState.HasSecondaryCamera() || mediaState.IsSharing() ||

            videoPermStopped;

        break;

    case EVtUiCmdDeactivateBT:

        result = !audioState.CanDeactivateBtHf();

        break;

    case EVtUiCmdSwitchFromBTToIHF:

        result = !audioState.CanDeactivateBtHf() ||

            !audioState.CanActivateLoudspeaker();

        break;

    case EVtUiCmdActivateBT:

        result = !audioState.CanActivateBtHf();

        break;

    case EVtUiCmdDeactivateLoudspeaker:

        result = !audioState.CanDeactivateLoudspeaker();

        break;

    case EVtUiCmdActivateLoudspeaker:

        result = !audioState.CanActivateLoudspeaker();

        break;

    case EVtUiCmdSwapImagesPlaces:

        // Swap image places is always shown in menu.

        result = EFalse;

        break;

    case EVtUiCmdAdjustVideo:

        // Adjust video is always shown in menu.

        result = EFalse;

        break;

    case EVtUiCmdAdjustVideoVideoQuality:

        result = EFalse;

        break;

    case EVtUiCmdAdjustVideoWhiteBalance:

        result = !iUiStates.IsWhiteBalanceSettingAvailable() || frozen;

        break;

    case EVtUiCmdAdjustVideoBrightness:

          result =!iUiStates.IsBrightnessSettingAvailable() || frozen;

        break;

    case EVtUiCmdAdjustVideoContrast:

        result =!iUiStates.IsContrastSettingAvailable() || frozen;

        break;

    case EVtUiCmdAdjustVideoColourTone:

        result = !iUiStates.IsColorToneSettingAvailable() || frozen;

        break;

    case EVtUiCmdZoom:

        result = frozen || disableVideoOptions || disabledVideo;

        break;

    case EVtUiCmdCreateVoice:

        // Downgrading to voice call is not possible if remote end MSISDN

        // is unavailable or there is waiting call.

        result = !iUiStates.IsCLIReceived() || iUiStates.IsWaitingCall();

        break;

    case EVtUiCmdGoToIdle:

#ifndef RD_BOOT_CUSTOMIZABLE_AI

        result = !iAIEnabled;

#else

        // When RD_BOOT_CUSTOMIZABLE_AI is defined, active idle is always

        // shown in menu

        // result = EFalse;

        // disable the go to idle when autolock is on.

        result = iUiStates.IsDeviceLockOn();

#endif //RD_BOOT_CUSTOMIZABLE_AI

        break;

    case EAknCmdHelp:

    	{

    	TVtUiHelpVariation hlpvariation;

        result = !hlpvariation.IsHelpSupported();

        }

        break;

    case EAknCmdExit:

        // Exit option is disabled by default. Change ETrue to EFalse

        // and it is in the menu.

        break;

    case EVtUiCmdEndActiveCall:

        // End active call always shown in menu.

        result = EFalse;

        break;

    case EVtUiCmdShareObjectImage:

        result = frozen || mediaState.IsNotAbleToShare() ||

            mediaState.IsInitializingShare() || videoPermStopped ||

            iAppUi.IsActiveCommand( EVtUiCmdShareObjectImage );

        break;

    case EVtUiCmdEnableMain:

        result = (  iAppUi.IsActiveCommand( EVtUiCmdEnableVideo ) ||

                    iAppUi.IsActiveCommand( EVtUiCmdDisableVideo ) ||

                 !disabledVideo || disableVideoOptions || videoPermStopped )

                  && ( iAppUi.IsActiveCommand ( EVtUiCmdEnableAudio ) ||

                  !disabledAudio || audioPermStopped );

        break;

    case EVtUiCmdEnableVideo:

        result = !disabledVideo || disableVideoOptions ||

            videoPermStopped;

        break;

    case EVtUiCmdEnableAudio:

        result = !disabledAudio || audioPermStopped;

        break;

    case EVtUiCmdEnableBoth:

        result = !disabledVideo || !disabledAudio || disableVideoOptions ||

            videoPermStopped || audioPermStopped;

        break;

    case EVtUiCmdDisableMain:

        result = ( iAppUi.IsActiveCommand( EVtUiCmdDisableVideo ) ||

                   iAppUi.IsActiveCommand( EVtUiCmdEnableVideo ) ||

                 disabledVideo || disableVideoOptions || videoPermStopped ) &&

                ( iAppUi.IsActiveCommand( EVtUiCmdDisableAudio ) ||

                disabledAudio || audioPermStopped );

        break;

    case EVtUiCmdDisableVideo:

        result = disabledVideo || disableVideoOptions || videoPermStopped;

        break;

    case EVtUiCmdDisableAudio:

        result = disabledAudio || audioPermStopped;

        break;

    case EVtUiCmdDisableBoth:

        result = disableVideoOptions || disabledVideo || disabledAudio ||

            videoPermStopped || audioPermStopped;

        break;

    case EVtUiCmdSendDTMF:

        if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )

            {

            result = EFalse;

            }

        else

            {

            result = ETrue;

            }

        break;

    default:

        aHandled = EFalse;

        break;

        }