/*

* Copyright (c) 2009 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:  A plug-in for disabling/enabling tacticons.

* Part of:      Tacticon Server.

*

*/

// INCLUDE FILES

#include <badesca.h>

#include <cfactionindication.h>

#include <e32property.h>

#include <centralrepository.h>

#include "tacticonactionplugin.h"

#include "tacticonprivatecrkeys.h"

#include "tacticontrace.h"

// CONSTANTS

// Constants for tactile feedback actions

_LIT( KTacticonAction,    "Tacticon" );

_LIT( KTacticonMode,      "Mode" );

_LIT( KTacticonCallDialling,     "CALL_DIALLING" );

_LIT( KTacticonCallConnected,    "CALL_CONNECTED" );

_LIT( KTacticonCallDisconnected, "CALL_DISCONNECTED" );

_LIT( KProximityOn,              "PROXIMITY_ON" );

_LIT( KProximityOff,             "PROXIMITY_OFF" );

// Security policy

_LIT_SECURITY_POLICY_PASS( KSecurityPolicy );

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

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

// CTacticonActionPlugIn::CTacticonActionPlugIn

// C++ default constructor.

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

//

CTacticonActionPlugIn::CTacticonActionPlugIn( ) 

 : CCFActionPlugIn(),

    iProximityDiscernible(ETrue), iCallInitiated( EFalse )                                  

    {

    }

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

// CTacticonActionPlugIn::NewL

// Two-phased constructor.

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

//

CTacticonActionPlugIn* CTacticonActionPlugIn::NewL( )

    {

    CTacticonActionPlugIn* self = CTacticonActionPlugIn::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CTacticonActionPlugIn::NewLC

// Two-phased constructor.

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

//

CTacticonActionPlugIn* CTacticonActionPlugIn::NewLC( )

    {

    CTacticonActionPlugIn* self = new( ELeave ) CTacticonActionPlugIn();

    CleanupStack::PushL( self );

    return self;

    }

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

// CTacticonActionPlugIn::~CTacticonActionPlugIn

// Destructor.

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

//

CTacticonActionPlugIn::~CTacticonActionPlugIn()

    {

    iTacticon.Close();

    }

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

// CTacticonActionPlugIn::InitializeL

// Initializes the plugin, called by the CF framework.

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

//

void CTacticonActionPlugIn::InitializeL()

    {

    TRACE("CTacticonActionPlugIn::InitializeL(): start");

    User::LeaveIfError( iTacticon.Connect() );

    CRepository* repository = CRepository::NewL( KCRUidTacticon );

    CleanupStack::PushL( repository );

    User::LeaveIfError( repository->Get( KTacticonDuringCall, 

                                         iEnabledDuringCall ) );

    User::LeaveIfError( repository->Get( KTacticonSet, 

                                         iTacticonCallSettings ) );

    CleanupStack::PopAndDestroy( repository );

    TRACE("CTacticonActionPlugIn::InitializeL(): end");

    }

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

// CTacticonActionPlugIn::ExecuteL

// Executes an action.

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

//

CCFActionPlugIn::TExecutionTime CTacticonActionPlugIn::ExecuteL(

    CCFActionIndication* aActionIndication )

    {

    TRACE("CTacticonActionPlugIn::ExecuteL(): start");

    // get action parameters

    const RKeyValueArray& parameters = aActionIndication->Parameters();

    for( TInt i = 0; i < parameters.Count(); i++ )

        {

        // get received parameter and its value

        TPtrC param( parameters[i]->Key() );

        TPtrC value( parameters[i]->Value() );

        // check command

        if ( param == KTacticonMode )

            {

            if ( value == KProximityOn )

                {

                TRACE("CTacticonActionPlugIn::ExecuteL(): Proximity ON");

                iProximityDiscernible = ETrue;

                }

            else if ( value == KProximityOff )

                {

                TRACE("CTacticonActionPlugIn::ExecuteL(): Proximity OFF");

                iProximityDiscernible = EFalse;

                }

            else if ( value == KTacticonCallDialling )

                {

                iCallInitiated = ETrue;

                }

            else if ( value == KTacticonCallConnected )

                {

                TRACE("CTacticonActionPlugIn::ExecuteL(): Call Connected");

                if ( iCallInitiated && 

                     !iProximityDiscernible &&

                   ( iTacticonCallSettings & KTacticonSetCallConnected ) )

                    {

                    iTacticon.PlayTacticon( ENeutralTacticon );

                    }                

                if ( !iEnabledDuringCall )

                    {

                    iTacticon.EnableTacticons( EFalse );

                    }

                }

            else if ( value == KTacticonCallDisconnected )

                {

                TRACE("CTacticonActionPlugIn::ExecuteL(): Call Disconnected");

                iTacticon.EnableTacticons( ETrue );

                iCallInitiated = EFalse;

                }                

            }            

        }

    TRACE("CTacticonActionPlugIn::ExecuteL(): end");

    // not async operation --> return always ENone

    return CCFActionPlugIn::ENone;

    }

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

// CTacticonActionPlugIn::GetActionsL

// Returns all the actions the plugin can perform.

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

//

void CTacticonActionPlugIn::GetActionsL( CDesCArray& aActionList ) const

    {

    TRACE("CTacticonActionPlugIn::GetActionsL(): start");

    aActionList.AppendL( KTacticonAction );

    TRACE("CTacticonActionPlugIn::GetActionsL(): end");

    }

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

// CTacticonActionPlugIn::SecurityPolicy

// Returns the capabilities required by the plugin.

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

//

const TSecurityPolicy& CTacticonActionPlugIn::SecurityPolicy() const

    {

    TRACE("CTacticonActionPlugIn::SecurityPolicy()");

    return KSecurityPolicy;

    }

// End of File