/*

* Copyright (c) 2009, 2010 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:  Handles the updating of dialer buttons

*

*/

#include <eikappui.h>

#include <eikenv.h>

#include <eikapp.h>

#include <eikcolib.h>

#include <gulicon.h>

#include <StringLoader.h>

#include <AknsUtils.h>

#include <phoneui.rsg>

#include <phoneui.mbg>

#include <pevirtualengine.h>

#include <data_caging_path_literals.hrh>

#include "cphonedialercontroller.h"

#include "cphoneeasydialingcontroller.h"

#include "cphonebubblewrapper.h"

#include "phoneui.hrh"

#include "tphonecmdparaminteger.h"

#include "cphonemainresourceresolver.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparamboolean.h"

_LIT ( KPhoneMifFileName, "phoneui.mif" );

/** States for Call button. */

enum TCallButtonState

    {

    ECallButtonCallState = 0,

    ECallButtonLogState,

    ECallButtonSendState

    };

static const CPhoneDialerController::TLocalButtonData KCallButtonDataTable[] =

    {

        },

        },

        }

    };

static const TInt KCallButtonDataTableCount = 

    sizeof( KCallButtonDataTable ) / sizeof( CPhoneDialerController::TLocalButtonData );

/** States for Phonebook button */

enum TPhonebookButtonState

    {

    EPhonebookButtonContactsState = 0,

    };

static const CPhoneDialerController::TLocalButtonData KPhonebookButtonDataTable[] =

    {

        },

        }

    };

static const TInt KPhonebookButtonDataTableCount = 

    sizeof( KPhonebookButtonDataTable ) / sizeof( CPhoneDialerController::TLocalButtonData );

/** States for Clear button */

enum TClearButtonState

    {

    EClearButtonClearState = 0

    };

static const CPhoneDialerController::TLocalButtonData KClearButtonDataTable[] =

    {

        }

    };

static const TInt KClearButtonDataTableCount = 

    sizeof( KClearButtonDataTable ) / sizeof( CPhoneDialerController::TLocalButtonData );

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

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

// Constructor

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

//

EXPORT_C CPhoneDialerController::CPhoneDialerController( 

                                        CPhoneBubbleWrapper* aBubbleWrapper,

                                        CCoeEnv& aCoeEnv ):

    iCoeEnv( aCoeEnv ),

    iBubbleWrapper( aBubbleWrapper )

    {

    }

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

// Second phase constructor

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

//

EXPORT_C void CPhoneDialerController::ConstructL()

    {

    }

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

// Static constructor

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

//

CPhoneDialerController* CPhoneDialerController::NewL( 

                                    CPhoneBubbleWrapper* aBubbleWrapper,

                                    CCoeEnv& aCoeEnv )

    {

    CPhoneDialerController* self = 

        new (ELeave) CPhoneDialerController( aBubbleWrapper, aCoeEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

EXPORT_C CPhoneDialerController::~CPhoneDialerController()

    {

    }

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

// SetRestrictedDialerL

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

//

void CPhoneDialerController::SetRestrictedDialer( TBool aRestricted )

    {

    iRestrictedDialer = aRestricted;

    }

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

// SetServiceCodeFlagL

//

// The flag rules wether green key is called "Send" or "Call"

// 

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

//

void CPhoneDialerController::SetServiceCodeFlag( 

    TPhoneCommandParam* aCommandParam )

    {

    // Check is the given parameter valid

    if ( aCommandParam->ParamId() == TPhoneCommandParam::EPhoneParamIdBoolean )

        {

        TPhoneCmdParamBoolean* serviceCodeFlag = 

            static_cast<TPhoneCmdParamBoolean*>( aCommandParam );

        iServiceCodeFlag = serviceCodeFlag->Boolean();

        }

    }

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

// SetEasyDialingController

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

//

void CPhoneDialerController::SetEasyDialingController( 

        CPhoneEasyDialingController* aController )

    {

    iEasyDialingController = aController;

    }

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

// CbaResourceId

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

//

EXPORT_C TInt CPhoneDialerController::CbaResourceId() const

    {

    return KErrNotFound;

    }

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

// MenuResourceId

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

//

EXPORT_C TInt CPhoneDialerController::MenuResourceId() const

    {

    return KErrNotFound;

    }

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

// NumberEntryPromptTextL

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

//

EXPORT_C const TDesC& CPhoneDialerController::NumberEntryPromptTextL()

    {

    return KNullDesC;

    }

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

// GetButtonData

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

//

EXPORT_C TInt CPhoneDialerController::GetButtonData( TButtonIndex aIndex, 

        RPointerArray<CButtonData>& aData ) const

    {

    TInt err = KErrNone;

    const TLocalButtonData* dataTable = NULL;

    TInt count = 0;

    // Select correct data table

    switch ( aIndex )

        {

        case ECallButton:

            dataTable = KCallButtonDataTable;

            count = KCallButtonDataTableCount;

            break;

        case EPhonebookButton:

            dataTable = KPhonebookButtonDataTable;

            count = KPhonebookButtonDataTableCount;

            break;

        case EClearButton:

            dataTable = KClearButtonDataTable;

            count = KClearButtonDataTableCount;

            break;

        default:

            break;

        }

    // Create data from the table

    if ( dataTable )

        {

        // Construct MIF file path

        TFileName mifPath( KDriveZ );

        mifPath.Append( KDC_APP_BITMAP_DIR );

        mifPath.Append( KPhoneMifFileName );

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        for ( TInt i = 0 ; i < count ; ++i )

            {

            CButtonData* btnData = NULL;

            TRAP( err, btnData = CreateButtonDataL( dataTable[i], skin, mifPath ) );

            if ( !err )

                {

                err = aData.Append( btnData );

                }

            if ( err )

                {

                // free all memory and stop here if something went wrong

                delete btnData;

                aData.ResetAndDestroy();

                i = count;

                }

            }

        }

    return err;

    }

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

// SetNumberEntryEmptyIsEmpty

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

//

EXPORT_C void CPhoneDialerController::SetNumberEntryIsEmpty( TBool aEmpty )

    {

    iNumberAvailable = !aEmpty;

    }

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

// ButtonState

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

//

EXPORT_C TInt CPhoneDialerController::ButtonState( TButtonIndex aIndex ) const

    {

    TInt state( KErrNotFound );

    // Figure out correct state for each key

    switch ( aIndex )

        {

        case ECallButton:

            {

            if ( !iNumberAvailable )

                {

                // Show "Recent calls" when no number available

                state = ECallButtonLogState;

                }

            else if ( iServiceCodeFlag && !EasyDialingFocused() )

                {

                // Show "Send" if service code entered and contact list

                // is not focused.

                state = ECallButtonSendState;

                }

            else

                {

                // Show "Call" in all other cases

                state = ECallButtonCallState;

                }

            }

            break;

        case EPhonebookButton:

            {

            if ( !iNumberAvailable )

                {

                state = EPhonebookButtonContactsState;

                }

            else

                {

                state = EPhonebookButtonAddContactState;

                }

            }

            break;

        case EClearButton:

            {

            state = EClearButtonClearState;

            }

            break;

        default:

            break;

        }

    return state;

    }

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

// ButtonDimmed

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

//

EXPORT_C TBool CPhoneDialerController::ButtonDimmed( TButtonIndex aIndex ) const

    {

    TBool dimmed = EFalse;

    // Figure out correct state for each key

    switch ( aIndex )

        {

        case ECallButton:

			{

        	if ( iNumberAvailable )

        		{

        		// Dim send key if emergency call is active. 

        		// Do not dim send key if emergency call is not active,

        		// user must be able to make an emergency call whether 

        		// security mode is enabled or disabled.

        		dimmed = EmergencyCallActive();

        		}

        	else

        		{

        		// If there's no number available in dialer, we should dim

        		// send key if security mode is enabled.

        		// User cannot launch logs application.

        		dimmed = iRestrictedDialer;

        		}

			}

        	break;

        case EPhonebookButton:

            dimmed = iRestrictedDialer;

            break;

        case EClearButton:

            dimmed = !iNumberAvailable;

            break;

        default:

            break;

        }

    return dimmed;

    }

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

// EasyDialingAllowed

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

//

EXPORT_C TBool CPhoneDialerController::EasyDialingAllowed() const

    {

    return !iRestrictedDialer && !EmergencyCallActive();

    }

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

// EmergencyCallActive

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

//

EXPORT_C TBool CPhoneDialerController::EmergencyCallActive() const

    {

    TBool ret = EFalse;

    if ( iBubbleWrapper )

        {

        TPhoneCmdParamCallStateData callStateData;

        callStateData.SetCallState( EPEStateConnected );

        iBubbleWrapper->GetCallIdByState( &callStateData );

        ret = ( connected == KEmergencyCallId );

        }

    return ret;

    }

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

// EasyDialingFocused

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

//

TBool CPhoneDialerController::EasyDialingFocused() const

    {

    TBool edFocused = EFalse;

    if ( iEasyDialingController )

        {

        TInt commandResponse( EPhoneViewResponseFailed );

        TRAP_IGNORE( commandResponse = iEasyDialingController->HandleCommandL(

                EPhoneViewGetEasyDialingInFocusStatus) );

        edFocused = ( commandResponse == EPhoneViewResponseSuccess );

        }

    return edFocused;

    }

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

// CreateButtonDataL

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

//

MPhoneDialerController::CButtonData* CPhoneDialerController::CreateButtonDataL( 

        const TLocalButtonData& aSourceData, 

        MAknsSkinInstance* aSkin, 

        const TDesC& aMifFile ) const

    {

    // Create tooltip text

    HBufC* tooltip = StringLoader::LoadLC( aSourceData.iTooltipResourceId );

    // Create icon

    TAknsItemID skinId = { EAknsMajorGeneric, aSourceData.iSkinItemIdMinor };